corestore 6.0.3 → 6.0.6

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.3",
+  "version": "6.0.6",
   "description": "A Hypercore factory that simplifies managing collections of cores.",
   "main": "index.js",
   "scripts": {
@@ -19,6 +19,10 @@
     "url": "https://github.com/hypercore-protocol/corestore/issues"
   },
   "homepage": "https://github.com/hypercore-protocol/corestore#readme",
+  "files": [
+    "index.js",
+    "lib/**.js"
+  ],
   "devDependencies": {
     "brittle": "^3.0.0",
     "random-access-memory": "^5.0.1",

package/.github/workflows/test-node.yml

@@ -1,23 +0,0 @@
-name: Build Status
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    branches:
-      - master
-jobs:
-  build:
-    strategy:
-      matrix:
-        node-version: [lts/*]
-        os: [ubuntu-latest, macos-latest, windows-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - uses: actions/checkout@v2
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v2
-      with:
-        node-version: ${{ matrix.node-version }}
-    - run: npm install
-    - run: npm test

package/test/all.js

@@ -1,334 +0,0 @@
-const test = require('brittle')
-const crypto = require('hypercore-crypto')
-const ram = require('random-access-memory')
-const os = require('os')
-const path = require('path')
-const b4a = require('b4a')
-const sodium = require('sodium-universal')
-
-const Corestore = require('..')
-
-test('basic get with caching', async function (t) {
-  const store = new Corestore(ram)
-  const core1a = store.get({ name: 'core-1' })
-  const core1b = store.get({ name: 'core-1' })
-  const core2 = store.get({ name: 'core-2' })
-
-  await Promise.all([core1a.ready(), core1b.ready(), core2.ready()])
-
-  t.alike(core1a.key, core1b.key)
-  t.unlike(core1a.key, core2.key)
-
-  t.ok(core1a.writable)
-  t.ok(core1b.writable)
-
-  t.is(store.cores.size, 2)
-})
-
-test('basic get with custom keypair', async function (t) {
-  const store = new Corestore(ram)
-  const kp1 = crypto.keyPair()
-  const kp2 = crypto.keyPair()
-
-  const core1 = store.get(kp1)
-  const core2 = store.get(kp2)
-  await Promise.all([core1.ready(), core2.ready()])
-
-  t.alike(core1.key, kp1.publicKey)
-  t.alike(core2.key, kp2.publicKey)
-  t.ok(core1.writable)
-  t.ok(core2.writable)
-})
-
-test('basic namespaces', async function (t) {
-  const store = new Corestore(ram)
-  const ns1 = store.namespace('ns1')
-  const ns2 = store.namespace('ns2')
-  const ns3 = store.namespace('ns1') // Duplicate namespace
-
-  const core1 = ns1.get({ name: 'main' })
-  const core2 = ns2.get({ name: 'main' })
-  const core3 = ns3.get({ name: 'main' })
-  await Promise.all([core1.ready(), core2.ready(), core3.ready()])
-
-  t.absent(core1.key.equals(core2.key))
-  t.ok(core1.key.equals(core3.key))
-  t.ok(core1.writable)
-  t.ok(core2.writable)
-  t.ok(core3.writable)
-  t.is(store.cores.size, 2)
-
-  t.end()
-})
-
-test('basic replication', async function (t) {
-  const store1 = new Corestore(ram)
-  const store2 = new Corestore(ram)
-
-  const core1 = store1.get({ name: 'core-1' })
-  const core2 = store1.get({ name: 'core-2' })
-  await core1.append('hello')
-  await core2.append('world')
-
-  const core3 = store2.get({ key: core1.key })
-  const core4 = store2.get({ key: core2.key })
-
-  const s = store1.replicate(true)
-  s.pipe(store2.replicate(false)).pipe(s)
-
-  t.alike(await core3.get(0), Buffer.from('hello'))
-  t.alike(await core4.get(0), Buffer.from('world'))
-})
-
-test('replicating cores created after replication begins', async function (t) {
-  const store1 = new Corestore(ram)
-  const store2 = new Corestore(ram)
-
-  const s = store1.replicate(true, { live: true })
-  s.pipe(store2.replicate(false, { live: true })).pipe(s)
-
-  const core1 = store1.get({ name: 'core-1' })
-  const core2 = store1.get({ name: 'core-2' })
-  await core1.append('hello')
-  await core2.append('world')
-
-  const core3 = store2.get({ key: core1.key })
-  const core4 = store2.get({ key: core2.key })
-
-  t.alike(await core3.get(0), Buffer.from('hello'))
-  t.alike(await core4.get(0), Buffer.from('world'))
-})
-
-test('replicating cores using discovery key hook', async function (t) {
-  const dir = tmpdir()
-  let store1 = new Corestore(dir)
-  const store2 = new Corestore(ram)
-
-  const core = store1.get({ name: 'main' })
-  await core.append('hello')
-  const key = core.key
-
-  await store1.close()
-  store1 = new Corestore(dir)
-
-  const s = store1.replicate(true, { live: true })
-  s.pipe(store2.replicate(false, { live: true })).pipe(s)
-
-  const core2 = store2.get(key)
-  t.alike(await core2.get(0), Buffer.from('hello'))
-})
-
-test('nested namespaces', async function (t) {
-  const store = new Corestore(ram)
-  const ns1a = store.namespace('ns1').namespace('a')
-  const ns1b = store.namespace('ns1').namespace('b')
-
-  const core1 = ns1a.get({ name: 'main' })
-  const core2 = ns1b.get({ name: 'main' })
-  await Promise.all([core1.ready(), core2.ready()])
-
-  t.not(core1.key.equals(core2.key))
-  t.ok(core1.writable)
-  t.ok(core2.writable)
-  t.is(store.cores.size, 2)
-})
-
-test('core uncached when all sessions close', async function (t) {
-  const store = new Corestore(ram)
-  const core1 = store.get({ name: 'main' })
-  await core1.ready()
-  t.is(store.cores.size, 1)
-  await core1.close()
-  t.is(store.cores.size, 0)
-})
-
-test('writable core loaded from name userData', async function (t) {
-  const dir = tmpdir()
-
-  let store = new Corestore(dir)
-  let core = store.get({ name: 'main' })
-  await core.ready()
-  const key = core.key
-
-  t.ok(core.writable)
-  await core.append('hello')
-  t.is(core.length, 1)
-
-  await store.close()
-  store = new Corestore(dir)
-  core = store.get(key)
-  await core.ready()
-
-  t.ok(core.writable)
-  await core.append('world')
-  t.is(core.length, 2)
-  t.alike(await core.get(0), Buffer.from('hello'))
-  t.alike(await core.get(1), Buffer.from('world'))
-})
-
-test('writable core loaded from name and namespace userData', async function (t) {
-  const dir = tmpdir()
-
-  let store = new Corestore(dir)
-  let core = store.namespace('ns1').get({ name: 'main' })
-  await core.ready()
-  const key = core.key
-
-  t.ok(core.writable)
-  await core.append('hello')
-  t.is(core.length, 1)
-
-  await store.close()
-  store = new Corestore(dir)
-  core = store.get(key)
-  await core.ready()
-
-  t.ok(core.writable)
-  await core.append('world')
-  t.is(core.length, 2)
-  t.alike(await core.get(0), Buffer.from('hello'))
-  t.alike(await core.get(1), Buffer.from('world'))
-})
-
-test('storage locking', async function (t) {
-  const dir = tmpdir()
-
-  const store1 = new Corestore(dir)
-  await store1.ready()
-
-  const store2 = new Corestore(dir)
-  try {
-    await store2.ready()
-    t.fail('dir should have been locked')
-  } catch {
-    t.pass('dir was locked')
-  }
-})
-
-test('closing a namespace does not close cores', 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()])
-
-  await ns1.close()
-
-  t.is(store.cores.size, 2)
-  t.not(core1.closed)
-  t.not(core1.closed)
-
-  await store.close()
-
-  t.is(store.cores.size, 0)
-  t.ok(core1.closed)
-  t.ok(core2.closed)
-})
-
-test('findingPeers', async function (t) {
-  t.plan(6)
-
-  const store = new Corestore(ram)
-
-  const ns1 = store.namespace('ns1')
-  const ns2 = store.namespace('ns2')
-
-  const a = ns1.get(Buffer.alloc(32).fill('a'))
-  const b = ns2.get(Buffer.alloc(32).fill('b'))
-
-  const done = ns1.findingPeers()
-
-  let aUpdated = false
-  let bUpdated = false
-  let cUpdated = false
-
-  const c = ns1.get(Buffer.alloc(32).fill('c'))
-
-  a.update().then(function (bool) {
-    aUpdated = true
-  })
-
-  b.update().then(function (bool) {
-    bUpdated = true
-  })
-
-  c.update().then(function (bool) {
-    cUpdated = true
-  })
-
-  await new Promise(resolve => setImmediate(resolve))
-
-  t.is(aUpdated, false)
-  t.is(bUpdated, true)
-  t.is(cUpdated, false)
-
-  done()
-
-  await new Promise(resolve => setImmediate(resolve))
-
-  t.is(aUpdated, true)
-  t.is(bUpdated, true)
-  t.is(cUpdated, true)
-})
-
-test('different primary keys yield different keypairs', async function (t) {
-  const pk1 = randomBytes(32)
-  const pk2 = randomBytes(32)
-  t.unlike(pk1, pk2)
-
-  const store1 = new Corestore(ram, { primaryKey: pk1 })
-  const store2 = new Corestore(ram, { primaryKey: pk2 })
-
-  const kp1 = await store1.createKeyPair('hello')
-  const kp2 = await store2.createKeyPair('hello')
-
-  t.unlike(kp1.publicKey, kp2.publicKey)
-})
-
-test('keypair auth sign', async function (t) {
-  const store = new Corestore(ram)
-  const keyPair = await store.createKeyPair('foo')
-  const message = b4a.from('hello world')
-
-  const sig = keyPair.auth.sign(message)
-
-  t.is(sig.length, 64)
-  t.ok(crypto.verify(message, sig, keyPair.publicKey))
-  t.absent(crypto.verify(message, b4a.alloc(64), keyPair.publicKey))
-})
-
-test('keypair auth verify', async function (t) {
-  const store = new Corestore(ram)
-  const keyPair = await store.createKeyPair('foo')
-  const message = b4a.from('hello world')
-
-  const sig = crypto.sign(message, keyPair.secretKey)
-
-  t.is(sig.length, 64)
-  t.ok(keyPair.auth.verify(message, sig))
-  t.absent(keyPair.auth.verify(message, b4a.alloc(64)))
-})
-
-test('core caching after reopen regression', async function (t) {
-  const store = new Corestore(ram)
-  const core = store.get({ name: 'test-core' })
-  await core.ready()
-
-  core.close()
-  await core.opening
-
-  const core2 = store.get({ name: 'test-core' })
-  await core2.ready()
-
-  t.pass('did not infinite loop')
-})
-
-function tmpdir () {
-  return path.join(os.tmpdir(), 'corestore-' + Math.random().toString(16).slice(2))
-}
-
-function randomBytes (n) {
-  const buf = b4a.allocUnsafe(n)
-  sodium.randombytes_buf(buf)
-  return buf
-}

package/test/cache.js

@@ -1,46 +0,0 @@
-const test = require('brittle')
-const RAM = require('random-access-memory')
-
-const Corestore = require('..')
-
-test('core cache', async function (t) {
-  const store = new Corestore(RAM, { cache: true })
-
-  const core = store.get({ name: 'core' })
-  await core.append(['a', 'b', 'c'])
-
-  const p = core.get(0)
-  const q = core.get(0)
-
-  t.is(await p, await q)
-})
-
-test('clear cache on truncate', async function (t) {
-  const store = new Corestore(RAM, { cache: true })
-
-  const core = store.get({ name: 'core' })
-  await core.append(['a', 'b', 'c'])
-
-  const p = core.get(0)
-
-  await core.truncate(0)
-  await core.append('d')
-
-  const q = core.get(0)
-
-  t.alike(await p, Buffer.from('a'))
-  t.alike(await q, Buffer.from('d'))
-})
-
-test('core cache on namespace', async function (t) {
-  const store = new Corestore(RAM, { cache: true })
-  const ns1 = store.namespace('test-namespace-1')
-
-  const c1 = store.get({ name: 'test-core' })
-  const c2 = ns1.get({ name: 'test-core' })
-
-  await Promise.all([c1.ready(), c2.ready()])
-
-  t.ok(c1.cache)
-  t.ok(c2.cache)
-})

package/test/helpers/index.js

@@ -1,19 +0,0 @@
-const fs = require('fs').promises
-
-async function cleanup (dirs) {
-  return Promise.allSettled(dirs.map(dir => fs.rmdir(dir, { recursive: true })))
-}
-
-function delay (ms, cb) {
-  return new Promise(resolve => {
-    setTimeout(() => {
-      if (cb) cb()
-      resolve()
-    }, ms)
-  })
-}
-
-module.exports = {
-  delay,
-  cleanup
-}