hypercore 11.0.20 → 11.0.22

package/index.js

@@ -247,19 +247,6 @@ class Hypercore extends EventEmitter {
     this.core.replicator.updateActivity(this._active ? 1 : -1)
   }
 
-  _setupSession (parent) {
-    if (!this.keyPair) this.keyPair = parent.keyPair
-
-    const s = parent.state
-
-    if (s) {
-      const shouldSnapshot = this.snapshotted && !s.isSnapshot()
-      this.state = shouldSnapshot ? s.snapshot() : s.ref()
-    }
-
-    if (this.snapshotted && this.core && !this._snapshot) this._updateSnapshot()
-  }
-
   async _open (storage, key, opts) {
     const preload = opts.preload || (opts.parent && opts.parent.preload)
 
@@ -339,7 +326,18 @@ class Hypercore extends EventEmitter {
 
     if (parent) {
       if (parent._stateIndex === -1) await parent.ready()
-      this._setupSession(parent)
+      if (!this.keyPair) this.keyPair = parent.keyPair
+
+      const ps = parent.state
+
+      if (ps) {
+        const shouldSnapshot = this.snapshotted && !ps.isSnapshot()
+        this.state = shouldSnapshot ? await ps.snapshot() : ps.ref()
+      }
+
+      if (this.snapshotted && this.core && !this._snapshot) {
+        this._updateSnapshot()
+      }
     }
 
     if (opts.exclusive && opts.writable !== false) {

package/lib/session-state.js

@@ -24,6 +24,7 @@ module.exports = class SessionState {
     this.lingers = null
 
     this.parent = parent
+    this.atomized = null
     this.mutex = new Mutex()
 
     this.blocks = blocks
@@ -122,6 +123,33 @@ module.exports = class SessionState {
     return MerkleTree.size(this.roots)
   }
 
+  async getFlushedTreeInfo (storage) {
+    if (!this.atomized || !this.atomized.flushing) return this.treeInfo()
+    await this.atomized.flushed()
+
+    let rx = storage.read()
+    const headPromise = rx.getHead()
+    const authPromise = rx.getAuth()
+
+    rx.tryFlush()
+    const [head, auth] = await Promise.all([headPromise, authPromise])
+
+    rx = storage.read()
+    const rootPromises = []
+    for (const r of flat.fullRoots(head.length * 2)) {
+      rootPromises.push(rx.getTreeNode(r))
+    }
+
+    rx.tryFlush()
+    return {
+      fork: head.fork,
+      roots: await Promise.all(rootPromises),
+      length: head.length,
+      prologue: auth.manifest && auth.manifest.prologue,
+      signature: head.signature
+    }
+  }
+
   treeInfo () {
     return {
       fork: this.fork,
@@ -137,6 +165,7 @@ module.exports = class SessionState {
 
     this.active = 0
     this.mutex.destroy(new Error('Closed')).catch(noop)
+    if (this.parent && this.parent.atomized) this.parent.atomized = null
 
     const closing = this.storage.close()
 
@@ -153,14 +182,16 @@ module.exports = class SessionState {
     return closing
   }
 
-  snapshot () {
+  async snapshot () {
+    const storage = this.storage.snapshot()
+
     const s = new SessionState(
       this.core,
       null,
-      this.storage.snapshot(),
+      storage,
       this.blocks,
-      this.tree.clone(),
-      this.treeInfo(),
+      this.tree.clone(storage),
+      await this.getFlushedTreeInfo(storage),
       this.name
     )
 
@@ -214,46 +245,62 @@ module.exports = class SessionState {
     }
   }
 
-  _commit () {
-    const bitfield = this._pendingBitfield
-    this._pendingBitfield = null
+  _precommit () {
+    this.commiting = true
+  }
+
+  async _commit () {
+    await this.mutex.lock()
 
-    return this.parent._oncommit(this, bitfield)
+    try {
+      const bitfield = this._pendingBitfield
+      this._pendingBitfield = null
+      await this.parent._oncommit(this, bitfield)
+    } finally {
+      this.commiting = false
+      this.mutex.unlock()
+    }
   }
 
   async _oncommit (src, bitfield) {
-    const currLength = this.length
+    await this.mutex.lock()
 
-    this.fork = src.fork
-    this.length = src.length
-    this.roots = src.roots.slice()
-    this.signature = src.signature
+    try {
+      const currLength = this.length
 
-    const tree = {
-      fork: this.fork,
-      length: this.length,
-      rootHash: this.hash(),
-      signature: this.signature
-    }
+      this.fork = src.fork
+      this.length = src.length
+      this.roots = src.roots.slice()
+      this.signature = src.signature
 
-    const rx = src.storage.read()
-    const dependencyPromise = rx.getDependency()
+      const tree = {
+        fork: this.fork,
+        length: this.length,
+        rootHash: this.hash(),
+        signature: this.signature
+      }
 
-    rx.tryFlush()
+      const rx = src.storage.read()
+      const dependencyPromise = rx.getDependency()
 
-    const dependency = await dependencyPromise
-    if (dependency && dependency.length > this.flushedLength()) {
-      this.storage.updateDependencyLength(dependency.length, false, true)
-    }
+      rx.tryFlush()
 
-    const truncated = bitfield ? bitfield.truncated : -1
+      const dependency = await dependencyPromise
+      if (dependency && dependency.length > this.flushedLength()) {
+        this.storage.updateDependencyLength(dependency.length, false, true)
+      }
 
-    if (truncated !== -1 && truncated < currLength) {
-      this.ontruncate(tree, truncated, currLength, true)
-      if (!bitfield || bitfield.length === 0) return
-    }
+      const truncated = bitfield ? bitfield.truncated : -1
+
+      if (truncated !== -1 && truncated < currLength) {
+        this.ontruncate(tree, truncated, currLength, true)
+        if (!bitfield || bitfield.length === 0) return
+      }
 
-    this.onappend(tree, bitfield, true)
+      this.onappend(tree, bitfield, true)
+    } finally {
+      this.mutex.unlock()
+    }
   }
 
   flushed () {
@@ -587,7 +634,6 @@ module.exports = class SessionState {
 
     try {
       if (length < this.length) throw INVALID_OPERATION('Can not catchup back in time')
-      if (length === this.length) return
 
       const origLength = this.length
 
@@ -641,14 +687,12 @@ module.exports = class SessionState {
       this.storage.updateDependencyLength(sharedLength, true)
       this.storage.updateDependencyLength(length, false)
 
-      const bitfield = { start: sharedLength, length: tree.length - sharedLength, drop: false }
-
       this.fork = tree.fork
       this.roots = roots
       this.length = tree.length
 
       if (truncating) this.ontruncate(tree, sharedLength, origLength, flushed)
-      if (sharedLength < length) this.onappend(tree, bitfield, flushed)
+      if (sharedLength < length) this.onappend(tree, null, flushed)
     } finally {
       this.mutex.unlock()
     }
@@ -803,6 +847,7 @@ module.exports = class SessionState {
       srcLocked = true
 
       if (!(await this.core._validateCommit(state, treeLength))) return null
+      if (this.length > length) return null
 
       if (this.length < length && !signature) {
         if (!keyPair) keyPair = this.core.header.keyPair
@@ -968,6 +1013,10 @@ module.exports = class SessionState {
       }
     }
 
+    if (this.atomized && atom) {
+      throw new Error('Session already atomized')
+    }
+
     const tree = new MerkleTree(storage)
 
     const head = {
@@ -988,7 +1037,10 @@ module.exports = class SessionState {
       atom ? this.name : name
     )
 
-    if (atom) atom.onflush(state._commit.bind(state))
+    if (atom) {
+      this.atomized = atom
+      atom.onflush(state._commit.bind(state))
+    }
 
     return state
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hypercore",
-  "version": "11.0.20",
+  "version": "11.0.22",
   "description": "Hypercore is a secure, distributed append-only log",
   "main": "index.js",
   "scripts": {