hypercore 11.0.19 → 11.0.21

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
@@ -40,7 +41,7 @@ module.exports = class SessionState {
 
     if (treeInfo.roots.length) this.setRoots(treeInfo.roots)
 
-    this.snapshotCompatLength = this.isSnapshot() ? this.length : -1
+    this.snapshotCompatLength = this.isSnapshot() ? Math.min(this.length, this.core.state.length) : -1
 
     this.active = 0
 
@@ -91,7 +92,8 @@ module.exports = class SessionState {
   }
 
   signedLength () {
-    return Math.min(this.flushedLength(), this.core.state.length)
+    const l = Math.min(this.flushedLength(), this.core.state.length)
+    return this.isSnapshot() && l > this.snapshotCompatLength ? this.snapshotCompatLength : l
   }
 
   unref () {
@@ -121,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,
@@ -136,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()
 
@@ -152,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
     )
 
@@ -213,46 +245,62 @@ module.exports = class SessionState {
     }
   }
 
-  _commit () {
-    const bitfield = this._pendingBitfield
-    this._pendingBitfield = null
+  _precommit () {
+    this.commiting = true
+  }
 
-    return this.parent._oncommit(this, bitfield)
+  async _commit () {
+    await this.mutex.lock()
+
+    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 dependency = await dependencyPromise
+      if (dependency && dependency.length > this.flushedLength()) {
+        this.storage.updateDependencyLength(dependency.length, false, true)
+      }
 
-    const truncated = bitfield ? bitfield.truncated : -1
+      const truncated = bitfield ? bitfield.truncated : -1
 
-    if (truncated !== -1 && truncated < currLength) {
-      this.ontruncate(tree, truncated, currLength, true)
-      if (!bitfield || bitfield.length === 0) return
-    }
+      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 () {
@@ -350,6 +398,12 @@ module.exports = class SessionState {
 
       const { dependency, tree, roots } = await this._truncate(tx, batch)
 
+      for (const sessionState of this.core.sessionStates) {
+        if (sessionState.isSnapshot() && sessionState.name === this.name && length < sessionState.snapshotCompatLength) {
+          sessionState.snapshotCompatLength = length
+        }
+      }
+
       const flushed = await this.flush()
 
       this.fork = tree.fork
@@ -524,6 +578,12 @@ module.exports = class SessionState {
     if (!flushed) this._updateBitfield(bitfield)
     else if (this.isDefault()) this.core.ontruncate(tree, bitfield)
 
+    for (const sessionState of this.core.sessionStates) {
+      if (sessionState.isSnapshot() && sessionState.name === this.name && to < sessionState.snapshotCompatLength) {
+        sessionState.snapshotCompatLength = to
+      }
+    }
+
     for (let i = this.sessions.length - 1; i >= 0; i--) {
       this.sessions[i].emit('truncate', to, tree.fork)
     }
@@ -955,6 +1015,10 @@ module.exports = class SessionState {
       }
     }
 
+    if (this.atomized && atom) {
+      throw new Error('Session already atomized')
+    }
+
     const tree = new MerkleTree(storage)
 
     const head = {
@@ -975,7 +1039,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.19",
+  "version": "11.0.21",
   "description": "Hypercore is a secure, distributed append-only log",
   "main": "index.js",
   "scripts": {