corestore 6.0.2 → 6.0.5

package/index.js

@@ -26,6 +26,8 @@ module.exports = class Corestore extends EventEmitter {
     this._keyStorage = null
     this._primaryKey = opts.primaryKey
     this._namespace = opts.namespace || DEFAULT_NAMESPACE
+
+    this._root = opts._root || this
     this._replicationStreams = opts._streams || []
     this._overwrite = opts.overwrite === true
 
@@ -37,6 +39,7 @@ module.exports = class Corestore extends EventEmitter {
 
     if (this._namespace.byteLength !== 32) throw new Error('Namespace must be a 32-byte Buffer or Uint8Array')
 
+    this._closing = null
     this._opening = opts._opening ? opts._opening.then(() => this._open()) : this._open()
     this._opening.catch(safetyCatch)
     this.ready = () => this._opening
@@ -178,7 +181,7 @@ module.exports = class Corestore extends EventEmitter {
       userData,
       auth,
       cache: opts.cache,
-      createIfMissing: !opts._discoveryKey,
+      createIfMissing: opts.createIfMissing === false ? false : !opts._discoveryKey,
       keyPair: keyPair && keyPair.publicKey
         ? {
             publicKey: keyPair.publicKey,
@@ -187,6 +190,7 @@ module.exports = class Corestore extends EventEmitter {
         : null
     })
 
+    if (this._root._closing) throw new Error('The corestore is closed')
     this.cores.set(id, core)
     core.ready().then(() => {
       for (const { stream } of this._replicationStreams) {
@@ -226,6 +230,7 @@ module.exports = class Corestore extends EventEmitter {
   }
 
   get (opts = {}) {
+    if (this._root._closing) throw new Error('The corestore is closed')
     opts = validateGetOptions(opts)
 
     if (opts.cache !== false) {
@@ -288,6 +293,7 @@ module.exports = class Corestore extends EventEmitter {
       primaryKey: this._opening.then(() => this.primaryKey),
       namespace: generateNamespace(this._namespace, name),
       cache: this.cache,
+      _root: this._root,
       _opening: this._opening,
       _cores: this.cores,
       _streams: this._replicationStreams,
@@ -295,23 +301,25 @@ module.exports = class Corestore extends EventEmitter {
     })
   }
 
-  async _close () {
-    await this._opening
-    if (!b4a.equals(this._namespace, DEFAULT_NAMESPACE)) {
-      // namespaces should not release resources on close
-      // TODO: Refactor the namespace close logic to actually close sessions with ref counting
-      return
-    }
+  _closeNamespace () {
     const closePromises = []
-    for (const core of this.cores.values()) {
-      closePromises.push(core.close())
+    for (const session of this._sessions) {
+      closePromises.push(session.close())
     }
-    await Promise.allSettled(closePromises)
+    return Promise.allSettled(closePromises)
+  }
+
+  async _closePrimaryNamespace () {
+    const closePromises = []
+    // At this point, the primary namespace is closing.
     for (const { stream, isExternal } of this._replicationStreams) {
       // Only close streams that were created by the Corestore
       if (!isExternal) stream.destroy()
     }
-    if (!this._keyStorage) return
+    for (const core of this.cores.values()) {
+      closePromises.push(forceClose(core))
+    }
+    await Promise.allSettled(closePromises)
     await new Promise((resolve, reject) => {
       this._keyStorage.close(err => {
         if (err) return reject(err)
@@ -320,10 +328,17 @@ module.exports = class Corestore extends EventEmitter {
     })
   }
 
+  async _close () {
+    await this._opening
+    await this._closeNamespace()
+    if (this._root === this) {
+      await this._closePrimaryNamespace()
+    }
+  }
+
   close () {
     if (this._closing) return this._closing
     this._closing = this._close()
-    this._closing.catch(safetyCatch)
     return this._closing
   }
 }
@@ -371,3 +386,7 @@ function defaultCache () {
 function isStream (s) {
   return typeof s === 'object' && s && typeof s.pipe === 'function'
 }
+
+function forceClose (core) {
+  return Promise.all(core.sessions.map(s => s.close()))
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "corestore",
-  "version": "6.0.2",
+  "version": "6.0.5",
   "description": "A Hypercore factory that simplifies managing collections of cores.",
   "main": "index.js",
   "scripts": {
@@ -21,12 +21,12 @@
   "homepage": "https://github.com/hypercore-protocol/corestore#readme",
   "devDependencies": {
     "brittle": "^3.0.0",
-    "random-access-memory": "^4.0.0",
+    "random-access-memory": "^5.0.1",
     "standardx": "^7.0.0"
   },
   "dependencies": {
     "b4a": "^1.3.1",
-    "hypercore": "v10.0.0",
+    "hypercore": "^10.2.0",
     "hypercore-crypto": "^3.2.1",
     "safety-catch": "^1.0.1",
     "sodium-universal": "^3.0.4",

package/test/all.js

@@ -40,6 +40,24 @@ test('basic get with custom keypair', async function (t) {
   t.ok(core2.writable)
 })
 
+test('get with createIfMissing=false throws if new core', async function (t) {
+  const store = new Corestore(ram)
+  const core1a = store.get({ name: 'core-1', createIfMissing: false })
+
+  await t.exception(core1a.ready(), 'No Hypercore is stored here')
+})
+
+test('get with createIfMissing=false works if no new core', async function (t) {
+  const store = new Corestore(ram)
+  const name = 'core-1'
+
+  const core1 = store.get({ name })
+  await core1.ready()
+
+  const core1Too = store.get({ name, createIfMissing: false })
+  await t.execution(core1Too.ready())
+})
+
 test('basic namespaces', async function (t) {
   const store = new Corestore(ram)
   const ns1 = store.namespace('ns1')
@@ -205,13 +223,17 @@ test('storage locking', async function (t) {
   }
 })
 
-test('closing a namespace does not close cores', async function (t) {
+test('cores close when their last referencing namespace closes', async function (t) {
   const store = new Corestore(ram)
   const ns1 = store.namespace('ns1')
   const core1 = ns1.get({ name: 'core-1' })
   const core2 = ns1.get({ name: 'core-2' })
   await Promise.all([core1.ready(), core2.ready()])
 
+  const core3 = store.get(core1.key)
+  const core4 = store.get(core2.key)
+  await Promise.all([core3.ready(), core4.ready()])
+
   await ns1.close()
 
   t.is(store.cores.size, 2)
@@ -323,6 +345,61 @@ test('core caching after reopen regression', async function (t) {
   t.pass('did not infinite loop')
 })
 
+test('closing a namespace does not close the root corestore', async function (t) {
+  const store = new Corestore(ram)
+  const core1 = store.get({ name: 'core-1' })
+  await core1.ready()
+
+  const ns = store.namespace('test-namespace')
+  const core2 = ns.get(core1.key)
+  await core2.ready()
+
+  await ns.close()
+  t.is(core1.closed, false)
+  t.is(core2.closed, true)
+})
+
+test('open a new session concurrently with a close should throw', async function (t) {
+  const store = new Corestore(ram)
+  const ns = store.namespace('test-namespace')
+
+  const core1 = ns.get({ name: 'core-1' })
+  store.close()
+
+  try {
+    await core1.ready()
+    t.fail('core1 should not have opened')
+  } catch {
+    t.pass('core1 did not open after corestore close')
+  }
+})
+
+test('closing the root corestore closes all sessions', async function (t) {
+  const store = new Corestore(ram)
+  const ns = store.namespace('test-namespace')
+
+  const core1 = store.get({ name: 'core-1' })
+  const core2 = store.get({ name: 'core-2' })
+  await Promise.all([core1.ready(), core2.ready()])
+
+  const core3 = ns.get(core1.key)
+  const core4 = ns.get(core2.key)
+  await Promise.all([core3.ready(), core4.ready()])
+
+  await store.close()
+
+  t.is(core1.closed, true)
+  t.is(core2.closed, true)
+
+  try {
+    const core5 = ns.get({ name: 'core-3' })
+    await core5.ready()
+    t.fail('core5 should not have opened after corestore close')
+  } catch (err) {
+    t.pass('core5 did not open after corestore close')
+  }
+})
+
 function tmpdir () {
   return path.join(os.tmpdir(), 'corestore-' + Math.random().toString(16).slice(2))
 }