libp2p 0.35.8 → 0.36.0

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

@@ -1,180 +1,250 @@
 '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 { equals: uint8ArrayEquals } = require('uint8arrays/equals')
-
+const { codes } = require('../errors')
 const PeerId = require('peer-id')
+const { equals: uint8ArrayEquals } = require('uint8arrays/equals')
 
-const Book = require('./book')
-
-const {
-  codes: { ERR_INVALID_PARAMETERS }
-} = require('../errors')
+const log = Object.assign(debug('libp2p:peer-store:metadata-book'), {
+  error: debug('libp2p:peer-store:metadata-book:err')
+})
 
 /**
- * @typedef {import('./')} PeerStore
+ * @typedef {import('./types').PeerStore} PeerStore
+ * @typedef {import('./types').MetadataBook} MetadataBook
  */
 
+const EVENT_NAME = 'change:metadata'
+
 /**
- * @extends {Book}
- *
- * @fires MetadataBook#change:metadata
+ * @implements {MetadataBook}
  */
-class MetadataBook extends Book {
+class PeerStoreMetadataBook {
   /**
    * The MetadataBook is responsible for keeping the known supported
-   * protocols of a peer.
+   * 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 MetadataBook to emit:
-     * "change:metadata" - emitted when the known metadata of a peer change.
-     */
-    super({
-      peerStore,
-      eventName: 'change:metadata',
-      eventProperty: 'metadata'
-    })
-
-    /**
-     * Map known peers to their known protocols.
-     *
-     * @type {Map<string, Map<string, Uint8Array>>}
-     */
-    this.data = new Map()
+  constructor (emit, store) {
+    this._emit = emit
+    this._store = store
   }
 
   /**
-   * Set metadata key and value of a provided peer.
+   * Get the known data of a provided peer
    *
-   * @override
    * @param {PeerId} peerId
-   * @param {string} key - metadata key
-   * @param {Uint8Array} value - metadata value
-   * @returns {MetadataBook}
    */
-  // @ts-ignore override with more then the parameters expected in Book
-  set (peerId, key, value) {
+  async get (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'), ERR_INVALID_PARAMETERS)
+      throw errcode(new Error('peerId must be an instance of peer-id'), codes.ERR_INVALID_PARAMETERS)
     }
 
-    if (typeof key !== 'string' || !(value instanceof Uint8Array)) {
-      log.error('valid key and value must be provided to store data')
-      throw errcode(new Error('valid key and value must be provided'), ERR_INVALID_PARAMETERS)
+    log('get await read lock')
+    const release = await this._store.lock.readLock()
+    log('get got read lock')
+
+    try {
+      const peer = await this._store.load(peerId)
+
+      return peer.metadata
+    } catch (/** @type {any} */ err) {
+      if (err.code !== codes.ERR_NOT_FOUND) {
+        throw err
+      }
+    } finally {
+      log('get release read lock')
+      release()
     }
 
-    this._setValue(peerId, key, value)
-
-    return this
+    return new Map()
   }
 
   /**
-   * Set data into the datastructure
+   * Get specific metadata value, if it exists
    *
    * @param {PeerId} peerId
    * @param {string} key
-   * @param {Uint8Array} value
-   * @param {object} [opts]
-   * @param {boolean} [opts.emit]
    */
-  _setValue (peerId, key, value, { emit = true } = {}) {
-    const id = peerId.toB58String()
-    const rec = this.data.get(id) || new Map()
-    const recMap = rec.get(key)
-
-    // Already exists and is equal
-    if (recMap && uint8ArrayEquals(value, recMap)) {
-      log(`the metadata provided to store is equal to the already stored for ${id} on ${key}`)
-      return
+  async getValue (peerId, key) {
+    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)
     }
 
-    rec.set(key, value)
-    this.data.set(id, rec)
-
-    emit && this._emit(peerId, key)
+    log('getValue await read lock')
+    const release = await this._store.lock.readLock()
+    log('getValue got read lock')
+
+    try {
+      const peer = await this._store.load(peerId)
+
+      return peer.metadata.get(key)
+    } catch (/** @type {any} */ err) {
+      if (err.code !== codes.ERR_NOT_FOUND) {
+        throw err
+      }
+    } finally {
+      log('getValue release write lock')
+      release()
+    }
   }
 
   /**
-   * Get the known data of a provided peer.
-   *
    * @param {PeerId} peerId
-   * @returns {Map<string, Uint8Array>|undefined}
+   * @param {Map<string, Uint8Array>} metadata
    */
-  get (peerId) {
+  async set (peerId, metadata) {
     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)
+    }
+
+    if (!metadata || !(metadata instanceof Map)) {
+      log.error('valid metadata must be provided to store data')
+      throw errcode(new Error('valid metadata must be provided'), codes.ERR_INVALID_PARAMETERS)
     }
 
-    return this.data.get(peerId.toB58String())
+    log('set await write lock')
+    const release = await this._store.lock.writeLock()
+    log('set got write lock')
+
+    try {
+      await this._store.mergeOrCreate(peerId, {
+        metadata
+      })
+    } finally {
+      log('set release write lock')
+      release()
+    }
+
+    this._emit(EVENT_NAME, { peerId, metadata })
   }
 
   /**
-   * Get specific metadata value, if it exists
+   * Set metadata key and value of a provided peer
    *
    * @param {PeerId} peerId
-   * @param {string} key
-   * @returns {Uint8Array | undefined}
+   * @param {string} key - metadata key
+   * @param {Uint8Array} value - metadata value
    */
-  getValue (peerId, key) {
+  async setValue (peerId, key, value) {
     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)
+    }
+
+    if (typeof key !== 'string' || !(value instanceof Uint8Array)) {
+      log.error('valid key and value must be provided to store data')
+      throw errcode(new Error('valid key and value must be provided'), codes.ERR_INVALID_PARAMETERS)
+    }
+
+    log('setValue await write lock')
+    const release = await this._store.lock.writeLock()
+    log('setValue got write lock')
+
+    let updatedPeer
+
+    try {
+      try {
+        const existingPeer = await this._store.load(peerId)
+        const existingValue = existingPeer.metadata.get(key)
+
+        if (existingValue != null && uint8ArrayEquals(value, existingValue)) {
+          return
+        }
+      } catch (/** @type {any} */ err) {
+        if (err.code !== codes.ERR_NOT_FOUND) {
+          throw err
+        }
+      }
+
+      updatedPeer = await this._store.mergeOrCreate(peerId, {
+        metadata: new Map([[key, value]])
+      })
+    } finally {
+      log('setValue release write lock')
+      release()
     }
 
-    const rec = this.data.get(peerId.toB58String())
-    return rec && rec.get(key)
+    this._emit(EVENT_NAME, { peerId, metadata: updatedPeer.metadata })
   }
 
   /**
-   * Deletes the provided peer from the book.
-   *
    * @param {PeerId} peerId
-   * @returns {boolean}
    */
-  delete (peerId) {
+  async delete (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)
     }
 
-    if (!this.data.delete(peerId.toB58String())) {
-      return false
-    }
+    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)
 
-    this._emit(peerId)
+      if (has) {
+        await this._store.patch(peerId, {
+          metadata: new Map()
+        })
+      }
+    } finally {
+      log('delete release write lock')
+      release()
+    }
 
-    return true
+    if (has) {
+      this._emit(EVENT_NAME, { peerId, metadata: new Map() })
+    }
   }
 
   /**
-   * Deletes the provided peer metadata key from the book.
-   *
    * @param {PeerId} peerId
    * @param {string} key
-   * @returns {boolean}
    */
-  deleteValue (peerId, key) {
+  async deleteValue (peerId, key) {
     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('deleteValue await write lock')
+    const release = await this._store.lock.writeLock()
+    log('deleteValue got write lock')
 
-    if (!rec || !rec.delete(key)) {
-      return false
-    }
+    let metadata
+
+    try {
+      const peer = await this._store.load(peerId)
+      metadata = peer.metadata
 
-    this._emit(peerId, key)
+      metadata.delete(key)
 
-    return true
+      await this._store.patch(peerId, {
+        metadata
+      })
+    } catch (/** @type {any} **/ err) {
+      if (err.code !== codes.ERR_NOT_FOUND) {
+        throw err
+      }
+    } finally {
+      log('deleteValue release write lock')
+      release()
+    }
+
+    if (metadata) {
+      this._emit(EVENT_NAME, { peerId, metadata })
+    }
   }
 }
 
-module.exports = MetadataBook
+module.exports = PeerStoreMetadataBook

package/src/peer-store/pb/peer.d.ts

@@ -0,0 +1,222 @@
+import * as $protobuf from "protobufjs";
+/** Properties of a Peer. */
+export interface IPeer {
+
+    /** Peer addresses */
+    addresses?: (IAddress[]|null);
+
+    /** Peer protocols */
+    protocols?: (string[]|null);
+
+    /** Peer metadata */
+    metadata?: (IMetadata[]|null);
+
+    /** Peer pubKey */
+    pubKey?: (Uint8Array|null);
+
+    /** Peer peerRecordEnvelope */
+    peerRecordEnvelope?: (Uint8Array|null);
+}
+
+/** Represents a Peer. */
+export class Peer implements IPeer {
+
+    /**
+     * Constructs a new Peer.
+     * @param [p] Properties to set
+     */
+    constructor(p?: IPeer);
+
+    /** Peer addresses. */
+    public addresses: IAddress[];
+
+    /** Peer protocols. */
+    public protocols: string[];
+
+    /** Peer metadata. */
+    public metadata: IMetadata[];
+
+    /** Peer pubKey. */
+    public pubKey?: (Uint8Array|null);
+
+    /** Peer peerRecordEnvelope. */
+    public peerRecordEnvelope?: (Uint8Array|null);
+
+    /** Peer _pubKey. */
+    public _pubKey?: "pubKey";
+
+    /** Peer _peerRecordEnvelope. */
+    public _peerRecordEnvelope?: "peerRecordEnvelope";
+
+    /**
+     * Encodes the specified Peer message. Does not implicitly {@link Peer.verify|verify} messages.
+     * @param m Peer message or plain object to encode
+     * @param [w] Writer to encode to
+     * @returns Writer
+     */
+    public static encode(m: IPeer, w?: $protobuf.Writer): $protobuf.Writer;
+
+    /**
+     * Decodes a Peer message from the specified reader or buffer.
+     * @param r Reader or buffer to decode from
+     * @param [l] Message length if known beforehand
+     * @returns Peer
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): Peer;
+
+    /**
+     * Creates a Peer message from a plain object. Also converts values to their respective internal types.
+     * @param d Plain object
+     * @returns Peer
+     */
+    public static fromObject(d: { [k: string]: any }): Peer;
+
+    /**
+     * Creates a plain object from a Peer message. Also converts values to other types if specified.
+     * @param m Peer
+     * @param [o] Conversion options
+     * @returns Plain object
+     */
+    public static toObject(m: Peer, o?: $protobuf.IConversionOptions): { [k: string]: any };
+
+    /**
+     * Converts this Peer to JSON.
+     * @returns JSON object
+     */
+    public toJSON(): { [k: string]: any };
+}
+
+/** Properties of an Address. */
+export interface IAddress {
+
+    /** Address multiaddr */
+    multiaddr?: (Uint8Array|null);
+
+    /** Address isCertified */
+    isCertified?: (boolean|null);
+}
+
+/** Represents an Address. */
+export class Address implements IAddress {
+
+    /**
+     * Constructs a new Address.
+     * @param [p] Properties to set
+     */
+    constructor(p?: IAddress);
+
+    /** Address multiaddr. */
+    public multiaddr: Uint8Array;
+
+    /** Address isCertified. */
+    public isCertified?: (boolean|null);
+
+    /** Address _isCertified. */
+    public _isCertified?: "isCertified";
+
+    /**
+     * Encodes the specified Address message. Does not implicitly {@link Address.verify|verify} messages.
+     * @param m Address message or plain object to encode
+     * @param [w] Writer to encode to
+     * @returns Writer
+     */
+    public static encode(m: IAddress, w?: $protobuf.Writer): $protobuf.Writer;
+
+    /**
+     * Decodes an Address message from the specified reader or buffer.
+     * @param r Reader or buffer to decode from
+     * @param [l] Message length if known beforehand
+     * @returns Address
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): Address;
+
+    /**
+     * Creates an Address message from a plain object. Also converts values to their respective internal types.
+     * @param d Plain object
+     * @returns Address
+     */
+    public static fromObject(d: { [k: string]: any }): Address;
+
+    /**
+     * Creates a plain object from an Address message. Also converts values to other types if specified.
+     * @param m Address
+     * @param [o] Conversion options
+     * @returns Plain object
+     */
+    public static toObject(m: Address, o?: $protobuf.IConversionOptions): { [k: string]: any };
+
+    /**
+     * Converts this Address to JSON.
+     * @returns JSON object
+     */
+    public toJSON(): { [k: string]: any };
+}
+
+/** Properties of a Metadata. */
+export interface IMetadata {
+
+    /** Metadata key */
+    key?: (string|null);
+
+    /** Metadata value */
+    value?: (Uint8Array|null);
+}
+
+/** Represents a Metadata. */
+export class Metadata implements IMetadata {
+
+    /**
+     * Constructs a new Metadata.
+     * @param [p] Properties to set
+     */
+    constructor(p?: IMetadata);
+
+    /** Metadata key. */
+    public key: string;
+
+    /** Metadata value. */
+    public value: Uint8Array;
+
+    /**
+     * Encodes the specified Metadata message. Does not implicitly {@link Metadata.verify|verify} messages.
+     * @param m Metadata message or plain object to encode
+     * @param [w] Writer to encode to
+     * @returns Writer
+     */
+    public static encode(m: IMetadata, w?: $protobuf.Writer): $protobuf.Writer;
+
+    /**
+     * Decodes a Metadata message from the specified reader or buffer.
+     * @param r Reader or buffer to decode from
+     * @param [l] Message length if known beforehand
+     * @returns Metadata
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): Metadata;
+
+    /**
+     * Creates a Metadata message from a plain object. Also converts values to their respective internal types.
+     * @param d Plain object
+     * @returns Metadata
+     */
+    public static fromObject(d: { [k: string]: any }): Metadata;
+
+    /**
+     * Creates a plain object from a Metadata message. Also converts values to other types if specified.
+     * @param m Metadata
+     * @param [o] Conversion options
+     * @returns Plain object
+     */
+    public static toObject(m: Metadata, o?: $protobuf.IConversionOptions): { [k: string]: any };
+
+    /**
+     * Converts this Metadata to JSON.
+     * @returns JSON object
+     */
+    public toJSON(): { [k: string]: any };
+}