libp2p 0.35.4 → 0.35.8-bf1fc32

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

@@ -1,171 +1,237 @@
 'use strict'
 
 const debug = require('debug')
-const log = Object.assign(debug('libp2p:peer-store:proto-book'), {
-  error: debug('libp2p:peer-store:proto-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')
-
 /**
- * @typedef {import('./')} PeerStore
+ * @typedef {import('./types').PeerStore} PeerStore
+ * @typedef {import('./types').ProtoBook} ProtoBook
  */
 
+const log = Object.assign(debug('libp2p:peer-store:proto-book'), {
+  error: debug('libp2p:peer-store:proto-book:err')
+})
+
+const EVENT_NAME = 'change:protocols'
+
 /**
- * @extends {Book}
- *
- * @fires ProtoBook#change:protocols
+ * @implements {ProtoBook}
  */
-class ProtoBook extends Book {
+class PersistentProtoBook {
   /**
-   * The ProtoBook is responsible for keeping the known supported
-   * protocols of a peer.
-   *
-   * @class
-   * @param {PeerStore} peerStore
+   * @param {PeerStore["emit"]} emit
+   * @param {import('./types').Store} store
    */
-  constructor (peerStore) {
-    /**
-     * PeerStore Event emitter, used by the ProtoBook to emit:
-     * "change:protocols" - emitted when the known protocols of a peer change.
-     */
-    super({
-      peerStore,
-      eventName: 'change:protocols',
-      eventProperty: 'protocols',
-      eventTransformer: (data) => Array.from(data)
-    })
-
-    /**
-     * Map known peers to their known protocols.
-     *
-     * @type {Map<string, Set<string>>}
-     */
-    this.data = new Map()
+  constructor (emit, store) {
+    this._emit = emit
+    this._store = store
+  }
+
+  /**
+   * @param {PeerId} peerId
+   */
+  async get (peerId) {
+    log('get wait for read lock')
+    const release = await this._store.lock.readLock()
+    log('get got read lock')
+
+    try {
+      const peer = await this._store.load(peerId)
+
+      return peer.protocols
+    } catch (/** @type {any} */ err) {
+      if (err.code !== codes.ERR_NOT_FOUND) {
+        throw err
+      }
+    } finally {
+      log('get release read lock')
+      release()
+    }
+
+    return []
   }
 
   /**
-   * Set known protocols of a provided peer.
-   * If the peer was not known before, it will be added.
-   *
-   * @override
    * @param {PeerId} peerId
    * @param {string[]} protocols
-   * @returns {ProtoBook}
    */
-  set (peerId, protocols) {
+  async set (peerId, protocols) {
     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)
     }
 
-    if (!protocols) {
+    if (!Array.isArray(protocols)) {
       log.error('protocols must be provided to store data')
-      throw errcode(new Error('protocols must be provided'), ERR_INVALID_PARAMETERS)
+      throw errcode(new Error('protocols must be provided'), codes.ERR_INVALID_PARAMETERS)
     }
 
-    const id = peerId.toB58String()
-    const recSet = this.data.get(id)
-    const newSet = new Set(protocols)
-
-    /**
-     * @param {Set<string>} a
-     * @param {Set<string>} b
-     */
-    const isSetEqual = (a, b) => a.size === b.size && [...a].every(value => b.has(value))
-
-    // Already knows the peer and the recorded protocols are the same?
-    // If yes, no changes needed!
-    if (recSet && isSetEqual(recSet, newSet)) {
-      log(`the protocols provided to store are equal to the already stored for ${id}`)
-      return this
-    }
+    log('set await write lock')
+    const release = await this._store.lock.writeLock()
+    log('set got write lock')
+
+    let updatedPeer
+
+    try {
+      try {
+        const peer = await this._store.load(peerId)
+
+        if (new Set([
+          ...protocols
+        ]).size === peer.protocols.length) {
+          return
+        }
+      } catch (/** @type {any} */ err) {
+        if (err.code !== codes.ERR_NOT_FOUND) {
+          throw err
+        }
+      }
+
+      updatedPeer = await this._store.patchOrCreate(peerId, {
+        protocols
+      })
 
-    this._setData(peerId, newSet)
-    log(`stored provided protocols for ${id}`)
+      log(`stored provided protocols for ${peerId.toB58String()}`)
+    } finally {
+      log('set release write lock')
+      release()
+    }
 
-    return this
+    this._emit(EVENT_NAME, { peerId, protocols: updatedPeer.protocols })
   }
 
   /**
-   * Adds known protocols of a provided peer.
-   * If the peer was not known before, it will be added.
-   *
    * @param {PeerId} peerId
    * @param {string[]} protocols
-   * @returns {ProtoBook}
    */
-  add (peerId, protocols) {
+  async add (peerId, protocols) {
     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)
     }
 
-    if (!protocols) {
+    if (!Array.isArray(protocols)) {
       log.error('protocols must be provided to store data')
-      throw errcode(new Error('protocols must be provided'), ERR_INVALID_PARAMETERS)
+      throw errcode(new Error('protocols must be provided'), codes.ERR_INVALID_PARAMETERS)
     }
 
-    const id = peerId.toB58String()
-    const recSet = this.data.get(id) || new Set()
-    const newSet = new Set([...recSet, ...protocols]) // Set Union
+    log('add await write lock')
+    const release = await this._store.lock.writeLock()
+    log('add got write lock')
+
+    let updatedPeer
+
+    try {
+      try {
+        const peer = await this._store.load(peerId)
+
+        if (new Set([
+          ...peer.protocols,
+          ...protocols
+        ]).size === peer.protocols.length) {
+          return
+        }
+      } catch (/** @type {any} */ err) {
+        if (err.code !== codes.ERR_NOT_FOUND) {
+          throw err
+        }
+      }
 
-    // Any new protocol added?
-    if (recSet.size === newSet.size) {
-      log(`the protocols provided to store are already stored for ${id}`)
-      return this
-    }
+      updatedPeer = await this._store.mergeOrCreate(peerId, {
+        protocols
+      })
 
-    this._setData(peerId, newSet)
-    log(`added provided protocols for ${id}`)
+      log(`added provided protocols for ${peerId.toB58String()}`)
+    } finally {
+      log('add release write lock')
+      release()
+    }
 
-    return this
+    this._emit(EVENT_NAME, { peerId, protocols: updatedPeer.protocols })
   }
 
   /**
-   * Removes known protocols of a provided peer.
-   * If the protocols did not exist before, nothing will be done.
-   *
    * @param {PeerId} peerId
    * @param {string[]} protocols
-   * @returns {ProtoBook}
    */
-  remove (peerId, protocols) {
+  async remove (peerId, protocols) {
     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)
     }
 
-    if (!protocols) {
+    if (!Array.isArray(protocols)) {
       log.error('protocols must be provided to store data')
-      throw errcode(new Error('protocols must be provided'), ERR_INVALID_PARAMETERS)
+      throw errcode(new Error('protocols must be provided'), codes.ERR_INVALID_PARAMETERS)
     }
 
-    const id = peerId.toB58String()
-    const recSet = this.data.get(id)
+    log('remove await write lock')
+    const release = await this._store.lock.writeLock()
+    log('remove got write lock')
+
+    let updatedPeer
+
+    try {
+      try {
+        const peer = await this._store.load(peerId)
+        const protocolSet = new Set(peer.protocols)
+
+        for (const protocol of protocols) {
+          protocolSet.delete(protocol)
+        }
 
-    if (recSet) {
-      const newSet = new Set([
-        ...recSet
-      ].filter((p) => !protocols.includes(p)))
+        if (peer.protocols.length === protocolSet.size) {
+          return
+        }
 
-      // Any protocol removed?
-      if (recSet.size === newSet.size) {
-        return this
+        protocols = Array.from(protocolSet)
+      } catch (/** @type {any} */ err) {
+        if (err.code !== codes.ERR_NOT_FOUND) {
+          throw err
+        }
       }
 
-      this._setData(peerId, newSet)
-      log(`removed provided protocols for ${id}`)
+      updatedPeer = await this._store.patchOrCreate(peerId, {
+        protocols
+      })
+    } finally {
+      log('remove release write lock')
+      release()
     }
 
-    return this
+    this._emit(EVENT_NAME, { peerId, protocols: updatedPeer.protocols })
+  }
+
+  /**
+   * @param {PeerId} peerId
+   */
+  async delete (peerId) {
+    log('delete await write lock')
+    const release = await this._store.lock.writeLock()
+    log('delete got write lock')
+    let has
+
+    try {
+      has = await this._store.has(peerId)
+
+      await this._store.patchOrCreate(peerId, {
+        protocols: []
+      })
+    } catch (/** @type {any} */ err) {
+      if (err.code !== codes.ERR_NOT_FOUND) {
+        throw err
+      }
+    } finally {
+      log('delete release write lock')
+      release()
+    }
+
+    if (has) {
+      this._emit(EVENT_NAME, { peerId, protocols: [] })
+    }
   }
 }
 
-module.exports = ProtoBook
+module.exports = PersistentProtoBook

package/src/peer-store/store.js

@@ -0,0 +1,250 @@
+'use strict'
+
+const debug = require('debug')
+const PeerId = require('peer-id')
+const errcode = require('err-code')
+const { codes } = require('../errors')
+const { Key } = require('interface-datastore/key')
+const { base32 } = require('multiformats/bases/base32')
+const { keys: { unmarshalPublicKey, marshalPublicKey } } = require('libp2p-crypto')
+const { Multiaddr } = require('multiaddr')
+const { Peer: PeerPB } = require('./pb/peer')
+// @ts-expect-error no types
+const mortice = require('mortice')
+const { equals: uint8arrayEquals } = require('uint8arrays/equals')
+
+const log = Object.assign(debug('libp2p:peer-store:store'), {
+  error: debug('libp2p:peer-store:store:err')
+})
+
+/**
+ * @typedef {import('./types').PeerStore} PeerStore
+ * @typedef {import('./types').EventName} EventName
+ * @typedef {import('./types').Peer} Peer
+ */
+
+const NAMESPACE_COMMON = '/peers/'
+
+class PersistentStore {
+  /**
+   * @param {import('interface-datastore').Datastore} datastore
+   */
+  constructor (datastore) {
+    this._datastore = datastore
+    this.lock = mortice('peer-store', {
+      singleProcess: true
+    })
+  }
+
+  /**
+   * @param {PeerId} peerId
+   * @returns {Key}
+   */
+  _peerIdToDatastoreKey (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)
+    }
+
+    const b32key = peerId.toString()
+    return new Key(`${NAMESPACE_COMMON}${b32key}`)
+  }
+
+  /**
+   * @param {PeerId} peerId
+   */
+  async has (peerId) {
+    return this._datastore.has(this._peerIdToDatastoreKey(peerId))
+  }
+
+  /**
+   * @param {PeerId} peerId
+   */
+  async delete (peerId) {
+    await this._datastore.delete(this._peerIdToDatastoreKey(peerId))
+  }
+
+  /**
+   * @param {PeerId} peerId
+   * @returns {Promise<import('./types').Peer>} peer
+   */
+  async load (peerId) {
+    const buf = await this._datastore.get(this._peerIdToDatastoreKey(peerId))
+    const peer = PeerPB.decode(buf)
+    const pubKey = peer.pubKey ? unmarshalPublicKey(peer.pubKey) : peerId.pubKey
+    const metadata = new Map()
+
+    for (const meta of peer.metadata) {
+      metadata.set(meta.key, meta.value)
+    }
+
+    return {
+      ...peer,
+      id: peerId,
+      pubKey,
+      addresses: peer.addresses.map(({ multiaddr, isCertified }) => ({
+        multiaddr: new Multiaddr(multiaddr),
+        isCertified: isCertified || false
+      })),
+      metadata,
+      peerRecordEnvelope: peer.peerRecordEnvelope || undefined
+    }
+  }
+
+  /**
+   * @param {Peer} peer
+   */
+  async save (peer) {
+    if (peer.pubKey != null && peer.id.pubKey != null && !uint8arrayEquals(peer.pubKey.bytes, peer.id.pubKey.bytes)) {
+      log.error('peer publicKey bytes do not match peer id publicKey bytes')
+      throw errcode(new Error('publicKey bytes do not match peer id publicKey bytes'), codes.ERR_INVALID_PARAMETERS)
+    }
+
+    const buf = PeerPB.encode({
+      addresses: peer.addresses.sort((a, b) => {
+        return a.multiaddr.toString().localeCompare(b.multiaddr.toString())
+      }).map(({ multiaddr, isCertified }) => ({
+        multiaddr: multiaddr.bytes,
+        isCertified
+      })),
+      protocols: peer.protocols.sort(),
+      pubKey: peer.pubKey ? marshalPublicKey(peer.pubKey) : undefined,
+      metadata: [...peer.metadata.keys()].sort().map(key => ({ key, value: peer.metadata.get(key) })),
+      peerRecordEnvelope: peer.peerRecordEnvelope
+    }).finish()
+
+    await this._datastore.put(this._peerIdToDatastoreKey(peer.id), buf)
+
+    return this.load(peer.id)
+  }
+
+  /**
+   * @param {PeerId} peerId
+   * @param {Partial<Peer>} data
+   */
+  async patch (peerId, data) {
+    const peer = await this.load(peerId)
+
+    return await this._patch(peerId, data, peer)
+  }
+
+  /**
+   * @param {PeerId} peerId
+   * @param {Partial<Peer>} data
+   */
+  async patchOrCreate (peerId, data) {
+    /** @type {Peer} */
+    let peer
+
+    try {
+      peer = await this.load(peerId)
+    } catch (/** @type {any} */ err) {
+      if (err.code !== codes.ERR_NOT_FOUND) {
+        throw err
+      }
+
+      peer = { id: peerId, addresses: [], protocols: [], metadata: new Map() }
+    }
+
+    return await this._patch(peerId, data, peer)
+  }
+
+  /**
+   * @param {PeerId} peerId
+   * @param {Partial<Peer>} data
+   * @param {Peer} peer
+   */
+  async _patch (peerId, data, peer) {
+    return await this.save({
+      ...peer,
+      ...data,
+      id: peerId
+    })
+  }
+
+  /**
+   * @param {PeerId} peerId
+   * @param {Partial<Peer>} data
+   */
+  async merge (peerId, data) {
+    const peer = await this.load(peerId)
+
+    return this._merge(peerId, data, peer)
+  }
+
+  /**
+   * @param {PeerId} peerId
+   * @param {Partial<Peer>} data
+   */
+  async mergeOrCreate (peerId, data) {
+    /** @type {Peer} */
+    let peer
+
+    try {
+      peer = await this.load(peerId)
+    } catch (/** @type {any} */ err) {
+      if (err.code !== codes.ERR_NOT_FOUND) {
+        throw err
+      }
+
+      peer = { id: peerId, addresses: [], protocols: [], metadata: new Map() }
+    }
+
+    return await this._merge(peerId, data, peer)
+  }
+
+  /**
+   * @param {PeerId} peerId
+   * @param {Partial<Peer>} data
+   * @param {Peer} peer
+   */
+  async _merge (peerId, data, peer) {
+    // if the peer has certified addresses, use those in
+    // favour of the supplied versions
+    /** @type {Map<string, boolean>} */
+    const addresses = new Map()
+
+    ;(data.addresses || []).forEach(addr => {
+      addresses.set(addr.multiaddr.toString(), addr.isCertified)
+    })
+
+    peer.addresses.forEach(({ multiaddr, isCertified }) => {
+      const addrStr = multiaddr.toString()
+      addresses.set(addrStr, Boolean(addresses.get(addrStr) || isCertified))
+    })
+
+    return await this.save({
+      id: peerId,
+      addresses: Array.from(addresses.entries()).map(([addrStr, isCertified]) => {
+        return {
+          multiaddr: new Multiaddr(addrStr),
+          isCertified
+        }
+      }),
+      protocols: Array.from(new Set([
+        ...(peer.protocols || []),
+        ...(data.protocols || [])
+      ])),
+      metadata: new Map([
+        ...(peer.metadata ? peer.metadata.entries() : []),
+        ...(data.metadata ? data.metadata.entries() : [])
+      ]),
+      pubKey: data.pubKey || (peer != null ? peer.pubKey : undefined),
+      peerRecordEnvelope: data.peerRecordEnvelope || (peer != null ? peer.peerRecordEnvelope : undefined)
+    })
+  }
+
+  async * all () {
+    for await (const key of this._datastore.queryKeys({
+      prefix: NAMESPACE_COMMON
+    })) {
+      // /peers/${peer-id-as-libp2p-key-cid-string-in-base-32}
+      const base32Str = key.toString().split('/')[2]
+      const buf = base32.decode(base32Str)
+
+      yield this.load(PeerId.createFromBytes(buf))
+    }
+  }
+}
+
+module.exports = PersistentStore