libp2p 0.35.7 → 0.35.9-rc.2

package/src/peer-store/index.js

@@ -1,152 +1,119 @@
 'use strict'
 
-const errcode = require('err-code')
-
+const debug = require('debug')
 const { EventEmitter } = require('events')
-const PeerId = require('peer-id')
-
 const AddressBook = require('./address-book')
 const KeyBook = require('./key-book')
 const MetadataBook = require('./metadata-book')
 const ProtoBook = require('./proto-book')
-
-const {
-  codes: { ERR_INVALID_PARAMETERS }
-} = require('../errors')
+const Store = require('./store')
 
 /**
- * @typedef {import('./address-book').Address} Address
+ * @typedef {import('./types').PeerStore} PeerStore
+ * @typedef {import('./types').Peer} Peer
+ * @typedef {import('peer-id')} PeerId
  */
 
+const log = Object.assign(debug('libp2p:peer-store'), {
+  error: debug('libp2p:peer-store:err')
+})
+
 /**
- * @extends {EventEmitter}
+ * An implementation of PeerStore that stores data in a Datastore
  *
- * @fires PeerStore#peer Emitted when a new peer is added.
- * @fires PeerStore#change:protocols Emitted when a known peer supports a different set of protocols.
- * @fires PeerStore#change:multiaddrs Emitted when a known peer has a different set of multiaddrs.
- * @fires PeerStore#change:pubkey Emitted emitted when a peer's public key is known.
- * @fires PeerStore#change:metadata Emitted when the known metadata of a peer change.
+ * @implements {PeerStore}
  */
-class PeerStore extends EventEmitter {
+class DefaultPeerStore extends EventEmitter {
   /**
-   * Peer object
-   *
-   * @typedef {Object} Peer
-   * @property {PeerId} id peer's peer-id instance.
-   * @property {Address[]} addresses peer's addresses containing its multiaddrs and metadata.
-   * @property {string[]} protocols peer's supported protocols.
-   * @property {Map<string, Uint8Array>|undefined} metadata peer's metadata map.
+   * @param {object} properties
+   * @param {PeerId} properties.peerId
+   * @param {import('interface-datastore').Datastore} properties.datastore
    */
-
-  /**
-   * Responsible for managing known peers, as well as their addresses, protocols and metadata.
-   *
-   * @param {object} options
-   * @param {PeerId} options.peerId
-   * @class
-   */
-  constructor ({ peerId }) {
+  constructor ({ peerId, datastore }) {
     super()
 
     this._peerId = peerId
+    this._store = new Store(datastore)
 
-    /**
-     * AddressBook containing a map of peerIdStr to Address.
-     */
-    this.addressBook = new AddressBook(this)
-
-    /**
-     * KeyBook containing a map of peerIdStr to their PeerId with public keys.
-     */
-    this.keyBook = new KeyBook(this)
-
-    /**
-     * MetadataBook containing a map of peerIdStr to their metadata Map.
-     */
-    this.metadataBook = new MetadataBook(this)
-
-    /**
-     * ProtoBook containing a map of peerIdStr to supported protocols.
-     */
-    this.protoBook = new ProtoBook(this)
+    this.addressBook = new AddressBook(this.emit.bind(this), this._store)
+    this.keyBook = new KeyBook(this.emit.bind(this), this._store)
+    this.metadataBook = new MetadataBook(this.emit.bind(this), this._store)
+    this.protoBook = new ProtoBook(this.emit.bind(this), this._store)
   }
 
-  /**
-   * Start the PeerStore.
-   */
-  start () {}
-
-  /**
-   * Stop the PeerStore.
-   */
-  stop () {}
+  async * getPeers () {
+    log('getPeers await read lock')
+    const release = await this._store.lock.readLock()
+    log('getPeers got read lock')
+
+    try {
+      for await (const peer of this._store.all()) {
+        if (peer.id.toB58String() === this._peerId.toB58String()) {
+          // Remove self peer if present
+          continue
+        }
+
+        yield peer
+      }
+    } finally {
+      log('getPeers release read lock')
+      release()
+    }
+  }
 
   /**
-   * Get all the stored information of every peer known.
+   * Delete the information of the given peer in every book
    *
-   * @returns {Map<string, Peer>}
+   * @param {PeerId} peerId
    */
-  get peers () {
-    const storedPeers = new Set([
-      ...this.addressBook.data.keys(),
-      ...this.keyBook.data.keys(),
-      ...this.protoBook.data.keys(),
-      ...this.metadataBook.data.keys()
-    ])
-
-    // Remove self peer if present
-    this._peerId && storedPeers.delete(this._peerId.toB58String())
-
-    const peersData = new Map()
-    storedPeers.forEach((idStr) => {
-      peersData.set(idStr, this.get(PeerId.createFromB58String(idStr)))
-    })
-
-    return peersData
+  async delete (peerId) {
+    log('delete await write lock')
+    const release = await this._store.lock.writeLock()
+    log('delete got write lock')
+
+    try {
+      await this._store.delete(peerId)
+    } finally {
+      log('delete release write lock')
+      release()
+    }
   }
 
   /**
-   * Delete the information of the given peer in every book.
+   * Get the stored information of a given peer
    *
    * @param {PeerId} peerId
-   * @returns {boolean} true if found and removed
    */
-  delete (peerId) {
-    const addressesDeleted = this.addressBook.delete(peerId)
-    const keyDeleted = this.keyBook.delete(peerId)
-    const protocolsDeleted = this.protoBook.delete(peerId)
-    const metadataDeleted = this.metadataBook.delete(peerId)
-
-    return addressesDeleted || keyDeleted || protocolsDeleted || metadataDeleted
+  async get (peerId) {
+    log('get await read lock')
+    const release = await this._store.lock.readLock()
+    log('get got read lock')
+
+    try {
+      return this._store.load(peerId)
+    } finally {
+      log('get release read lock')
+      release()
+    }
   }
 
   /**
-   * Get the stored information of a given peer.
+   * Returns true if we have a record of the peer
    *
    * @param {PeerId} peerId
-   * @returns {Peer|undefined}
    */
-  get (peerId) {
-    if (!PeerId.isPeerId(peerId)) {
-      throw errcode(new Error('peerId must be an instance of peer-id'), ERR_INVALID_PARAMETERS)
-    }
-
-    const id = this.keyBook.data.get(peerId.toB58String())
-    const addresses = this.addressBook.get(peerId)
-    const metadata = this.metadataBook.get(peerId)
-    const protocols = this.protoBook.get(peerId)
-
-    if (!id && !addresses && !metadata && !protocols) {
-      return undefined
-    }
-
-    return {
-      id: id || peerId,
-      addresses: addresses || [],
-      protocols: protocols || [],
-      metadata: metadata
+  async has (peerId) {
+    log('has await read lock')
+    const release = await this._store.lock.readLock()
+    log('has got read lock')
+
+    try {
+      return this._store.has(peerId)
+    } finally {
+      log('has release read lock')
+      release()
     }
   }
 }
 
-module.exports = PeerStore
+module.exports = DefaultPeerStore

package/src/peer-store/key-book.js

@@ -1,96 +1,141 @@
 'use strict'
 
 const debug = require('debug')
-const log = Object.assign(debug('libp2p:peer-store:key-book'), {
-  error: debug('libp2p:peer-store:key-book:err')
-})
 const errcode = require('err-code')
-
+const { codes } = require('../errors')
 const PeerId = require('peer-id')
-
-const Book = require('./book')
-
-const {
-  codes: { ERR_INVALID_PARAMETERS }
-} = require('../errors')
+const { equals: uint8arrayEquals } = require('uint8arrays/equals')
 
 /**
- * @typedef {import('./')} PeerStore
- * @typedef {import('libp2p-crypto').PublicKey} PublicKey
+ * @typedef {import('./types').PeerStore} PeerStore
+ * @typedef {import('./types').KeyBook} KeyBook
+ * @typedef {import('libp2p-interfaces/src/keys/types').PublicKey} PublicKey
  */
 
+const log = Object.assign(debug('libp2p:peer-store:key-book'), {
+  error: debug('libp2p:peer-store:key-book:err')
+})
+
+const EVENT_NAME = 'change:pubkey'
+
 /**
- * @extends {Book}
+ * @implements {KeyBook}
  */
-class KeyBook extends Book {
+class PeerStoreKeyBook {
   /**
    * The KeyBook is responsible for keeping the known public keys of a peer.
    *
-   * @class
-   * @param {PeerStore} peerStore
+   * @param {PeerStore["emit"]} emit
+   * @param {import('./types').Store} store
    */
-  constructor (peerStore) {
-    super({
-      peerStore,
-      eventName: 'change:pubkey',
-      eventProperty: 'pubkey',
-      eventTransformer: (data) => data.pubKey
-    })
-
-    /**
-     * Map known peers to their known Public Key.
-     *
-     * @type {Map<string, PeerId>}
-     */
-    this.data = new Map()
+  constructor (emit, store) {
+    this._emit = emit
+    this._store = store
   }
 
   /**
-   * Set the Peer public key.
+   * Set the Peer public key
    *
-   * @override
    * @param {PeerId} peerId
    * @param {PublicKey} publicKey
-   * @returns {KeyBook}
    */
-  set (peerId, publicKey) {
+  async set (peerId, publicKey) {
     if (!PeerId.isPeerId(peerId)) {
       log.error('peerId must be an instance of peer-id to store data')
-      throw errcode(new Error('peerId must be an instance of peer-id'), ERR_INVALID_PARAMETERS)
+      throw errcode(new Error('peerId must be an instance of peer-id'), codes.ERR_INVALID_PARAMETERS)
     }
 
-    const id = peerId.toB58String()
-    const recPeerId = this.data.get(id)
-
-    // If no record available, and this is valid
-    if (!recPeerId && publicKey) {
-      // This might be unecessary, but we want to store the PeerId
-      // to avoid an async operation when reconstructing the PeerId
-      peerId.pubKey = publicKey
+    if (!publicKey) {
+      log.error('publicKey must be an instance of PublicKey to store data')
+      throw errcode(new Error('publicKey must be an instance of PublicKey'), codes.ERR_INVALID_PARAMETERS)
+    }
 
-      this._setData(peerId, peerId)
-      log(`stored provided public key for ${id}`)
+    log('set await write lock')
+    const release = await this._store.lock.writeLock()
+    log('set got write lock')
+
+    let updatedKey = false
+
+    try {
+      try {
+        const existing = await this._store.load(peerId)
+
+        if (existing.pubKey && uint8arrayEquals(existing.pubKey.bytes, publicKey.bytes)) {
+          return
+        }
+      } catch (/** @type {any} */ err) {
+        if (err.code !== codes.ERR_NOT_FOUND) {
+          throw err
+        }
+      }
+
+      await this._store.patchOrCreate(peerId, {
+        pubKey: publicKey
+      })
+      updatedKey = true
+    } finally {
+      log('set release write lock')
+      release()
     }
 
-    return this
+    if (updatedKey) {
+      this._emit(EVENT_NAME, { peerId, pubKey: publicKey })
+    }
   }
 
   /**
-   * Get Public key of the given PeerId, if stored.
+   * Get Public key of the given PeerId, if stored
    *
-   * @override
    * @param {PeerId} peerId
-   * @returns {PublicKey | undefined}
    */
-  get (peerId) {
+  async get (peerId) {
     if (!PeerId.isPeerId(peerId)) {
-      throw errcode(new Error('peerId must be an instance of peer-id'), ERR_INVALID_PARAMETERS)
+      log.error('peerId must be an instance of peer-id to store data')
+      throw errcode(new Error('peerId must be an instance of peer-id'), codes.ERR_INVALID_PARAMETERS)
     }
 
-    const rec = this.data.get(peerId.toB58String())
+    log('get await write lock')
+    const release = await this._store.lock.readLock()
+    log('get got write lock')
+
+    try {
+      const peer = await this._store.load(peerId)
+
+      return peer.pubKey
+    } catch (/** @type {any} */ err) {
+      if (err.code !== codes.ERR_NOT_FOUND) {
+        throw err
+      }
+    } finally {
+      log('get release write lock')
+      release()
+    }
+  }
+
+  /**
+   * @param {PeerId} peerId
+   */
+  async delete (peerId) {
+    if (!PeerId.isPeerId(peerId)) {
+      log.error('peerId must be an instance of peer-id to store data')
+      throw errcode(new Error('peerId must be an instance of peer-id'), codes.ERR_INVALID_PARAMETERS)
+    }
+
+    log('delete await write lock')
+    const release = await this._store.lock.writeLock()
+    log('delete got write lock')
+
+    try {
+      await this._store.patchOrCreate(peerId, {
+        pubKey: undefined
+      })
+    } finally {
+      log('delete release write lock')
+      release()
+    }
 
-    return rec ? rec.pubKey : undefined
+    this._emit(EVENT_NAME, { peerId, pubKey: undefined })
   }
 }
 
-module.exports = KeyBook
+module.exports = PeerStoreKeyBook