autobee 2.5.2 → 2.5.3

package/README.md

@@ -133,6 +133,12 @@ Optionally pass `{ optimistic: true }` to write without waiting to be a confirme
 await db.append(buf, { optimistic: true })
 ```
 
+An optimistic node always reaches `apply`, whoever wrote it, and is always
+recorded afterwards. `apply` decides what it does: call `host.addWriter` to
+grant the writer, or do nothing to leave it unwritable. An op `apply` does not
+accept must be handled in `apply` (ie. ignored) - throwing is a bug, as for any
+other node, and closes the db.
+
 #### `await db.update()`
 
 Trigger a new apply cycle. Useful after replication to process new data.
@@ -216,7 +222,8 @@ Remove a writer by public key (Buffer or hex string).
 
 #### `host.ackWriter(key)`
 
-Acknowledge a writer without changing their permissions.
+Deprecated, a no-op. Optimistic nodes are always recorded once applied, whether
+or not apply acks the writer. Kept so existing apply functions keep working.
 
 #### `host.interrupt(reason)`
 

package/index.js

@@ -690,10 +690,7 @@ module.exports = class Autobee extends ReadyResource {
             break // revaluate conditions...
           }
 
-          if (await this._bumpPendingWriters()) {
-            this._needsUpdate = true
-            continue
-          }
+          if (await this._bumpPendingWriters()) continue
 
           if (!(await this._appendAck())) break
           this._needsUpdate = true
@@ -1156,7 +1153,10 @@ module.exports = class Autobee extends ReadyResource {
     if (!local && this._catchupMigratedNodes !== null) {
       const updated = await this._bumpMigratedWriters()
       this._catchupMigratedNodes = null
-      if (updated) return true
+      if (updated) {
+        this._needsUpdate = true
+        return true
+      }
     }
 
     // apply the best next node to keep the prefix stable
@@ -1165,64 +1165,17 @@ module.exports = class Autobee extends ReadyResource {
 
     const { writer: w, batch } = next
 
-    // 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 (!(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
-    }
+    const optimistic = this.optimistic && batch[0].optimistic
 
-    if (w.isAdded || (w.isRemoved && w.hasReferrals())) {
+    if (optimistic || w.isAdded || (w.isRemoved && w.hasReferrals())) {
       await this._processBatch(batch)
-      w.notify(batch)
+    } else {
+      w.removePending()
       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
-  }
-
-  async _optimisticBatch(batch) {
-    const rollbackSystem = this.system.bee.head()
-    const rollbackView = this._workingBee.head()
-
-    const t = await this.prepareBatch(batch)
-    if (t.view) this._workingBee.move(t.view)
-
-    for (const b of t.tip) {
-      const optimistic = b[0].optimistic
-      let accepted = false
-      try {
-        accepted = await this._applyBatch(b, optimistic)
-      } catch (err) {
-        if (!optimistic) throw err
-      }
-
-      // only check if batch was successful
-      if (b !== batch) continue
-
-      // 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()
-        return false
-      }
-    }
-
+    w.notify(batch)
+    this._needsUpdate = true
     return true
   }
 
@@ -1309,8 +1262,10 @@ module.exports = class Autobee extends ReadyResource {
       }
     }
 
-    // read before flush clears it
-    const accepted = this.system.touched(batch[0].key)
+    // an optimistic node is always consumed: record its length and, unless apply
+    // granted the writer, record the writer as removed so that only its
+    // optimistic nodes reach apply
+    if (optimistic) await this.system.ackWriter(batch[0].key)
 
     const changed = await this.system.flush(batch, this._workingBee)
 
@@ -1326,8 +1281,6 @@ module.exports = class Autobee extends ReadyResource {
       if (added) await this.writers.add(key)
       else await this.writers.remove(key)
     }
-
-    return accepted
   }
 
   async _storeBoot() {
@@ -1426,7 +1379,7 @@ module.exports = class Autobee extends ReadyResource {
   async _flushLocal() {
     // pull any available local nodes in before flushing
     while (!this._interrupting && (await this._bumpPendingWriters({ local: true }))) {
-      this._needsUpdate = true
+      // a bump that applied a batch flags the update itself
     }
 
     const flushed = await this.writers.flushLocal({

package/lib/apply-calls.js

@@ -41,10 +41,10 @@ class ApplyCalls {
     return this.auto.system.addWriter(key, { weight, isGenesis, coord, carrier })
   }
 
-  ackWriter(key) {
-    if (typeof key === 'string') key = ID.decode(key)
-    return this.auto.system.ackWriter(key)
-  }
+  // deprecated: every optimistic node is recorded once applied, whether or not
+  // apply acks its writer, so this has nothing left to do. kept so contracts
+  // written against older versions keep applying
+  ackWriter() {}
 
   removeWriter(key) {
     if (typeof key === 'string') key = ID.decode(key)

package/lib/system.js

@@ -90,9 +90,9 @@ module.exports = class Systembee {
     if (length === 0) {
       length = info ? info.length : 0
     }
-    // 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
+    // called for every optimistic node once applied. not 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
     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)
@@ -229,14 +229,9 @@ 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
+    // acked or removed - it is self-verifying, apply decides what it does
     if (optimistic) return true
     const id = b4a.toString(key, 'hex')
     const w = this.writers.get(id)

package/package.json

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