corestore 6.0.6 → 6.1.1

package/index.js

@@ -13,25 +13,26 @@ const CORES_DIR = 'cores'
 const PRIMARY_KEY_FILE_NAME = 'primary-key'
 const USERDATA_NAME_KEY = 'corestore/name'
 const USERDATA_NAMESPACE_KEY = 'corestore/namespace'
+const POOL_SIZE = 512 // how many open fds to aim for before cycling them
 
 module.exports = class Corestore extends EventEmitter {
   constructor (storage, opts = {}) {
     super()
 
-    this.storage = Hypercore.defaultStorage(storage, { lock: PRIMARY_KEY_FILE_NAME })
-    this.cores = opts._cores || new Map()
-    this.primaryKey = null
+    const root = opts._root
+
+    this.storage = Hypercore.defaultStorage(storage, { lock: PRIMARY_KEY_FILE_NAME, poolSize: opts.poolSize || POOL_SIZE })
+    this.cores = root ? root.cores : new Map()
     this.cache = !!opts.cache
+    this.primaryKey = opts.primaryKey || null
 
     this._keyStorage = null
-    this._primaryKey = opts.primaryKey
     this._namespace = opts.namespace || DEFAULT_NAMESPACE
 
-    this._root = opts._root || this
-    this._replicationStreams = opts._streams || []
+    this._root = root || this
+    this._replicationStreams = root ? root._replicationStreams : []
     this._overwrite = opts.overwrite === true
 
-    this._streamSessions = opts._streamSessions || new Map()
     this._sessions = new Set() // sessions for THIS namespace
 
     this._findingPeersCount = 0
@@ -40,9 +41,12 @@ 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 = this._open()
     this._opening.catch(safetyCatch)
-    this.ready = () => this._opening
+  }
+
+  ready () {
+    return this._opening
   }
 
   findingPeers () {
@@ -73,16 +77,19 @@ module.exports = class Corestore extends EventEmitter {
   }
 
   async _open () {
-    if (this._primaryKey) {
-      this.primaryKey = await this._primaryKey
-      return this.primaryKey
+    if (this._root !== this) {
+      await this._root._opening
+      this.primaryKey = this._root.primaryKey
+      return
     }
+
     this._keyStorage = this.storage(PRIMARY_KEY_FILE_NAME)
+
     this.primaryKey = await new Promise((resolve, reject) => {
       this._keyStorage.stat((err, st) => {
         if (err && err.code !== 'ENOENT') return reject(err)
         if (err || st.size < 32 || this._overwrite) {
-          const key = crypto.randomBytes(32)
+          const key = this.primaryKey || crypto.randomBytes(32)
           return this._keyStorage.write(0, key, err => {
             if (err) return reject(err)
             return resolve(key)
@@ -90,11 +97,11 @@ module.exports = class Corestore extends EventEmitter {
         }
         this._keyStorage.read(0, 32, (err, key) => {
           if (err) return reject(err)
+          if (this.primaryKey) return resolve(this.primaryKey)
           return resolve(key)
         })
       })
     })
-    return this.primaryKey
   }
 
   async _generateKeys (opts) {
@@ -150,7 +157,7 @@ module.exports = class Corestore extends EventEmitter {
   }
 
   async _preload (opts) {
-    await this.ready()
+    if (!this.primaryKey) await this._opening
 
     const { discoveryKey, keyPair, auth } = await this._generateKeys(opts)
     const id = b4a.toString(discoveryKey, 'hex')
@@ -194,10 +201,7 @@ module.exports = class Corestore extends EventEmitter {
     this.cores.set(id, core)
     core.ready().then(() => {
       for (const { stream } of this._replicationStreams) {
-        const sessions = this._streamSessions.get(stream)
-        const session = core.session()
-        sessions.push(session)
-        core.replicate(stream)
+        core.replicate(stream, { session: true })
       }
     }, () => {
       this.cores.delete(id)
@@ -268,36 +272,26 @@ module.exports = class Corestore extends EventEmitter {
       }
     })
 
-    const sessions = []
     for (const core of this.cores.values()) {
       if (!core.opened) continue // If the core is not opened, it will be replicated in preload.
-      const session = core.session()
-      sessions.push(session)
-      core.replicate(stream)
+      core.replicate(stream, { session: true })
     }
 
     const streamRecord = { stream, isExternal }
     this._replicationStreams.push(streamRecord)
-    this._streamSessions.set(stream, sessions)
 
     stream.once('close', () => {
       this._replicationStreams.splice(this._replicationStreams.indexOf(streamRecord), 1)
-      this._streamSessions.delete(stream)
-      Promise.all(sessions.map(s => s.close())).catch(safetyCatch)
     })
+
     return stream
   }
 
   namespace (name) {
     return new Corestore(this.storage, {
-      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,
-      _streamSessions: this._streamSessions
+      _root: this._root
     })
   }
 
@@ -387,6 +381,7 @@ function isStream (s) {
   return typeof s === 'object' && s && typeof s.pipe === 'function'
 }
 
-function forceClose (core) {
+async function forceClose (core) {
+  await core.ready()
   return Promise.all(core.sessions.map(s => s.close()))
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "corestore",
-  "version": "6.0.6",
+  "version": "6.1.1",
   "description": "A Hypercore factory that simplifies managing collections of cores.",
   "main": "index.js",
   "scripts": {
@@ -25,12 +25,12 @@
   ],
   "devDependencies": {
     "brittle": "^3.0.0",
-    "random-access-memory": "^5.0.1",
+    "random-access-memory": "^6.0.0",
     "standardx": "^7.0.0"
   },
   "dependencies": {
     "b4a": "^1.3.1",
-    "hypercore": "^10.2.0",
+    "hypercore": "^10.3.1",
     "hypercore-crypto": "^3.2.1",
     "safety-catch": "^1.0.1",
     "sodium-universal": "^3.0.4",