autobee 2.2.0 → 2.2.2

package/index.js

@@ -344,6 +344,29 @@ module.exports = class Autobee extends ReadyResource {
   async _close() {
     this._interrupting = true
 
+    // the local core holds the exclusive lock but the local writer closes it
+    // early in the teardown, so hand the lock to a detached session that
+    // outlives the teardown and only release it once everything is down
+    let lock = null
+
+    if (this.local.exclusive) {
+      lock = this.store.session()
+      const local = lock.get({ key: this.local.key, active: false })
+      await local.ready()
+
+      // transfer exclusiveness, the detached session now unlocks on close
+      local.exclusive = true
+      this.local.exclusive = false
+    }
+
+    try {
+      await this._teardown()
+    } finally {
+      if (lock) await lock.close()
+    }
+  }
+
+  async _teardown() {
     try {
       await ApplyView.close(this.view, this)
     } catch (err) {
@@ -351,7 +374,6 @@ module.exports = class Autobee extends ReadyResource {
     }
 
     if (this.writers) await this.writers.close()
-    await this.local.close()
     await this.system.close()
     await this._wakeup.close()
     if (this.bootstrap) await this.bootstrap.close()
@@ -366,6 +388,8 @@ module.exports = class Autobee extends ReadyResource {
     // don't rely on the store teardown to stop the notify watcher
     if (this._notifyHandler) this._notifyHandler.destroy()
 
+    await this.local.close()
+
     // rugpull the rest
     await this.store.close()
 

package/lib/writers.js

@@ -4,6 +4,7 @@ const Triggers = require('./triggers.js')
 const { LEGACY_OPLOG_VERSION } = require('./constants.js')
 const { resolveWeight } = require('./witness.js')
 const { WriterEncryption } = require('autobee-encryption')
+const ReadWriteLock = require('read-write-mutexify')
 
 const WRITER_PREFETCH = 10
 
@@ -25,6 +26,7 @@ class ActiveWriters {
 
     this._pendingBuffer = new Map()
     this._adding = new Map()
+    this._lock = new ReadWriteLock()
 
     this.localWriter = new Writer(this, auto.system, true, local, b4a.toString(local.key, 'hex'))
     this.localWriter.attach()
@@ -89,14 +91,27 @@ class ActiveWriters {
   }
 
   async rotateLocalWriter(core) {
-    this.clearLocal()
-    await this.localWriter.detachAndClose()
+    await this._lock.write.lock()
 
-    this.localWriter = new Writer(this, this.auto.system, true, core, b4a.toString(core.key, 'hex'))
-    this.localWriter.addPending()
-    this.auto.emit('writer', this.localWriter)
+    try {
+      this.clearLocal()
+      await this.localWriter.detachAndClose()
+
+      const id = b4a.toString(core.key, 'hex')
+
+      // a peer may already have announced this core (wakeup hint / link), in which
+      // case an external writer tracks it - drop it so only one writer owns the key
+      const existing = this.active.get(id)
+      if (existing) await existing.detachAndClose()
 
-    await this.updateLocalState()
+      this.localWriter = new Writer(this, this.auto.system, true, core, id)
+      // register in active like the constructor does, so add() finds it
+      this.localWriter.attach()
+
+      await this.updateLocalState()
+    } finally {
+      this._lock.write.unlock()
+    }
   }
 
   clearLocal() {
@@ -178,7 +193,7 @@ class ActiveWriters {
     return !!this.active.get(id)
   }
 
-  add(key) {
+  async add(key) {
     const id = b4a.toString(key, 'hex')
 
     let adding = this._adding.get(id)
@@ -187,44 +202,60 @@ class ActiveWriters {
     adding = this._add(key, id)
     this._adding.set(id, adding)
 
-    return adding.finally(() => {
+    try {
+      return await adding
+    } finally {
       this._adding.delete(id)
-    })
+    }
   }
 
-  // TODO: correct fix is writer as ReadyResource
   async _add(key, id) {
-    const local = b4a.equals(key, this.auto.local.key)
-    if (local) await this.updateLocalState()
+    await this._lock.read.lock()
 
-    let w = this.active.get(id)
-    if (w) return w
+    try {
+      if (this.auto._interrupting) return null
+
+      // judged against the writer we own, not auto.local - that flips before the
+      // rotation takes the write lock. an add that beats the rotation onto its
+      // key just makes an external writer, which the rotation then evicts
+      if (b4a.equals(key, this.localWriter.core.key)) {
+        await this.updateLocalState()
+        if (this.auto._interrupting) return null
+        // never track the local core with a second writer - reattach it if it
+        // was detached (i.e. removed earlier and now re-added)
+        this.localWriter.attach()
+        return this.localWriter
+      }
 
-    // no new sessions once teardown started
-    if (this.auto._interrupting) return null
+      let w = this.active.get(id)
+      if (w) return w
 
-    const encryption = this.auto.encryptionKey ? new WriterEncryption(this.auto) : null
+      const local = b4a.equals(key, this.auto.local.key)
+      const encryption = this.auto.encryptionKey ? new WriterEncryption(this.auto) : null
 
-    const core = this.auto.store.get({
-      active: false,
-      key,
-      encryption,
-      group: local || !this.auto.wakeupCapability ? null : this.auto.wakeupCapability.discoveryKey
-    })
+      const core = this.auto.store.get({
+        active: false,
+        key,
+        encryption,
+        group: local || !this.auto.wakeupCapability ? null : this.auto.wakeupCapability.discoveryKey
+      })
 
-    await core.ready()
-    await core.setUserData('referrer', this.auto.key)
+      await core.ready()
+      await core.setUserData('referrer', this.auto.key)
 
-    // teardown may have started underneath us
-    if (this.auto._interrupting) {
-      await core.close()
-      return null
-    }
+      // teardown may have started underneath us
+      if (this.auto._interrupting) {
+        await core.close()
+        return null
+      }
 
-    w = new Writer(this, this.auto.system, false, core, id)
-    w.attach()
+      w = new Writer(this, this.auto.system, false, core, id)
+      w.attach()
 
-    return w
+      return w
+    } finally {
+      this._lock.read.unlock()
+    }
   }
 
   async remove(key) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autobee",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "description": "Bee based autobase",
   "license": "Apache-2.0",
   "author": "Holepunch Inc.",
@@ -31,6 +31,7 @@
     "hypercore": "^11.33.2",
     "hypercore-id-encoding": "^1.3.0",
     "hyperschema": "^1.20.1",
+    "read-write-mutexify": "^2.1.0",
     "ready-guard": "^1.0.0",
     "ready-resource": "^1.2.0",
     "resolve-reject-promise": "^1.1.0",