feat: peerStore persistence

Author: vasco-santos

package.json

@@ -50,6 +50,7 @@
     "err-code": "^2.0.0",
     "events": "^3.1.0",
     "hashlru": "^2.3.0",
+    "interface-datastore": "^0.8.3",
     "ipfs-utils": "^2.2.0",
     "it-all": "^1.0.1",
     "it-buffer": "^0.1.2",

src/config.js

@@ -20,6 +20,9 @@ const DefaultConfig = {
   metrics: {
     enabled: false
   },
+  peerStore: {
+    persistence: true
+  },
   config: {
     dht: {
       enabled: false,

src/index.js

@@ -6,6 +6,7 @@ const globalThis = require('ipfs-utils/src/globalthis')
 const log = debug('libp2p')
 log.error = debug('libp2p:error')
 
+const { MemoryDatastore } = require('interface-datastore')
 const PeerId = require('peer-id')
 
 const peerRouting = require('./peer-routing')
@@ -43,9 +44,12 @@ class Libp2p extends EventEmitter {
     // and add default values where appropriate
     this._options = validateConfig(_options)
 
-    this.datastore = this._options.datastore
     this.peerId = this._options.peerId
-    this.peerStore = new PeerStore()
+    this.datastore = this._options.datastore || new MemoryDatastore()
+    this.peerStore = new PeerStore({
+      datastore: this.datastore,
+      ...this._options.peerStore
+    })
 
     // Addresses {listen, announce, noAnnounce}
     this.addresses = this._options.addresses
@@ -393,6 +397,9 @@ class Libp2p extends EventEmitter {
     // Listen on the provided transports
     await this.transportManager.listen()
 
+    // Start PeerStore
+    await this.peerStore.load()
+
     if (this._config.pubsub.enabled) {
       this.pubsub && this.pubsub.start()
     }

src/peer-store/README.md

@@ -83,7 +83,51 @@ Access to its underlying books:
 - `change:multiaadrs` - emitted when a known peer has a different set of multiaddrs.
 - `change:protocols` - emitted when a known peer supports a different set of protocols.
 
+## Data Persistence
+
+The data stored in the PeerStore will be persisted by default. Keeping a record of the peers already discovered by the peer, as well as their known data aims to improve the efficiency of peers joining the network after being offline.
+
+---
+TODO: Discuss if we should make it persisted by default now. Taking into consideration that we will use a MemoryDatastore by default, unless the user configures a datastore to use, it will be worthless. It might make sense to make it disabled by default until we work on improving configuration and provide good defauls for each environment.
+---
+
+The libp2p node will need to receive a [datastore](https://github.com/ipfs/interface-datastore), in order to store this data in a persistent way. Otherwise, it will be stored on a [memory datastore](https://github.com/ipfs/interface-datastore/blob/master/src/memory.js).
+
+A [datastore](https://github.com/ipfs/interface-datastore) stores its data in a key-value fashion. As a result, we need coherent keys so that we do not overwrite data.
+
+Taking into account that a datastore allows queries using a key prefix, we can find all the information if we define a consistent namespace that allow us to find the content without having any information. The namespaces were defined as follows:
+
+**AddressBook**
+
+All the knownw peer addresses are stored with a key pattern as follows:
+
+`/peers/addrs/<b32 peer id no padding>`
+
+**ProtoBook**
+
+All the knownw peer protocols are stored with a key pattern as follows:
+
+`/peers/protos/<b32 peer id no padding>`
+
+**KeyBook**
+
+_NOT_YET_IMPLEMENTED_
+
+All public and private keys are stored under the following pattern:
+
+` /peers/keys/<b32 peer id no padding>/{pub, priv}`
+
+**MetadataBook**
+
+_NOT_YET_IMPLEMENTED_
+
+Metadata is stored under the following key pattern:
+
+`/peers/metadata/<b32 peer id no padding>/<key>`
+
 ## Future Considerations
 
 - If multiaddr TTLs are added, the PeerStore may schedule jobs to delete all addresses that exceed the TTL to prevent AddressBook bloating
 - Further API methods will probably need to be added in the context of multiaddr validity and confidence.
+- When improving libp2p configuration for specific runtimes, we should take into account the PeerStore recommended datastore.
+- When improving libp2p configuration, we should think about a possible way of allowing the configuration of Bootstrap to be influenced by the persisted peers, as a way to decrease the load on Bootstrap nodes.

src/peer-store/address-book.js

@@ -9,14 +9,17 @@ const multiaddr = require('multiaddr')
 const PeerId = require('peer-id')
 
 const Book = require('./book')
+const Protobuf = require('./pb/address-book.proto')
 
 const {
-  ERR_INVALID_PARAMETERS
+  codes: { ERR_INVALID_PARAMETERS }
 } = require('../errors')
 
 /**
  * The AddressBook is responsible for keeping the known multiaddrs
  * of a peer.
+ * This data will be persisted in the PeerStore datastore as follows:
+ * /peers/addrs/<b32 peer id no padding>
  */
 class AddressBook extends Book {
   /**
@@ -35,7 +38,20 @@ class AddressBook extends Book {
      * "peer" - emitted when a peer is discovered by the node.
      * "change:multiaddrs" - emitted when the known multiaddrs of a peer change.
      */
-    super(peerStore, 'change:multiaddrs', 'multiaddrs')
+    super({
+      peerStore,
+      eventName: 'change:multiaddrs',
+      eventProperty: 'multiaddrs',
+      protoBuf: Protobuf,
+      dsPrefix: '/peers/addrs/',
+      eventTransformer: (data) => data.map((address) => address.multiaddr),
+      dsSetTransformer: (data) => ({
+        addrs: data.map((address) => address.multiaddr.buffer)
+      }),
+      dsGetTransformer: (data) => data.addrs.map((a) => ({
+        multiaddr: multiaddr(a)
+      }))
+    })
 
     /**
      * Map known peers to their known Addresses.
@@ -78,20 +94,14 @@ class AddressBook extends Book {
       }
     }
 
-    this.data.set(id, addresses)
-    this._setPeerId(peerId)
+    this._setData(peerId, addresses)
     log(`stored provided multiaddrs for ${id}`)
 
     // Notify the existance of a new peer
     if (!rec) {
       this._ps.emit('peer', peerId)
     }
 
-    this._ps.emit('change:multiaddrs', {
-      peerId,
-      multiaddrs: addresses.map((mi) => mi.multiaddr)
-    })
-
     return this
   }
 
@@ -127,16 +137,9 @@ class AddressBook extends Book {
       return this
     }
 
-    this._setPeerId(peerId)
-    this.data.set(id, addresses)
-
+    this._setData(peerId, addresses)
     log(`added provided multiaddrs for ${id}`)
 
-    this._ps.emit('change:multiaddrs', {
-      peerId,
-      multiaddrs: addresses.map((mi) => mi.multiaddr)
-    })
-
     // Notify the existance of a new peer
     if (!rec) {
       this._ps.emit('peer', peerId)
@@ -147,6 +150,7 @@ class AddressBook extends Book {
 
   /**
    * Transforms received multiaddrs into Address.
+   * @private
    * @param {Array<Multiaddr>} multiaddrs
    * @returns {Array<Address>}
    */

src/peer-store/book.js

@@ -1,20 +1,57 @@
 'use strict'
 
 const errcode = require('err-code')
+const debug = require('debug')
+const log = debug('libp2p:peer-store:book')
+log.error = debug('libp2p:peer-store:book:error')
+
+const { Key } = require('interface-datastore')
 const PeerId = require('peer-id')
 
 const {
-  ERR_INVALID_PARAMETERS
+  codes: { ERR_INVALID_PARAMETERS }
 } = require('../errors')
 
+const passthrough = data => data
+
 /**
  * The Book is the skeleton for the PeerStore books.
+ * It handles the PeerStore persistence and events.
  */
 class Book {
-  constructor (peerStore, eventName, eventProperty) {
+  /**
+   * @constructor
+   * @param {Object} properties
+   * @param {PeerStore} properties.peerStore PeerStore instance.
+   * @param {string} properties.eventName Name of the event to emit by the PeerStore.
+   * @param {string} properties.eventProperty Name of the property to emit by the PeerStore.
+   * @param {Object} properties.protoBuf Suffix of the Datastore Key
+   * @param {String} properties.dsPrefix Prefix of the Datastore Key
+   * @param {String} [properties.dsSuffix] Suffix of the Datastore Key
+   * @param {function} [properties.eventTransformer] Transformer function of the provided data for being emitted.
+   * @param {function} [properties.dsSetTransformer] Transformer function of the provided data for being persisted.
+   * @param {function} [properties.dsGetTransformer] Transformer function of the persisted data to be loaded.
+   */
+  constructor ({
+    peerStore,
+    eventName,
+    eventProperty,
+    protoBuf,
+    dsPrefix,
+    dsSuffix = '',
+    eventTransformer = passthrough,
+    dsSetTransformer = passthrough,
+    dsGetTransformer = passthrough
+  }) {
     this._ps = peerStore
     this.eventName = eventName
     this.eventProperty = eventProperty
+    this.protoBuf = protoBuf
+    this.dsPrefix = dsPrefix
+    this.dsSuffix = dsSuffix
+    this.eventTransformer = eventTransformer
+    this.dsSetTransformer = dsSetTransformer
+    this.dsGetTransformer = dsGetTransformer
 
     /**
      * Map known peers to their data.
@@ -23,6 +60,91 @@ class Book {
     this.data = new Map()
   }
 
+  /**
+   * Load data from peerStore datastore into the books datastructures.
+   * This will not persist the replicated data nor emit modify events.
+   * @private
+   * @return {Promise<void>}
+   */
+  async _loadData () {
+    if (!this._ps._datastore || !this._ps._enabledPersistance) {
+      return
+    }
+
+    const persistenceQuery = {
+      prefix: this.dsPrefix
+    }
+
+    for await (const { key, value } of this._ps._datastore.query(persistenceQuery)) {
+      try {
+        // PeerId to add to the book
+        const b32key = key.toString()
+          .replace(this.dsPrefix, '') // remove prefix from key
+          .replace(this.dsSuffix, '') // remove suffix from key
+        const peerId = PeerId.createFromCID(b32key)
+        // Data in the format to add to the book
+        const data = this.dsGetTransformer(this.protoBuf.decode(value))
+        // Add the book without persist the replicated data and emit modify
+        this._setData(peerId, data, {
+          persist: false,
+          emit: false
+        })
+      } catch (err) {
+        log.error(err)
+      }
+    }
+  }
+
+  /**
+   * Set data into the datastructure, persistence and emit it using the provided transformers.
+   * @private
+   * @param {PeerId} peerId peerId of the data to store
+   * @param {Array<*>} data data to store.
+   * @param {Object} [options] storing options.
+   * @param {boolean} [options.persist = true] persist the provided data.
+   * @param {boolean} [options.emit = true] emit the provided data.
+   * @return {Promise<void>}
+   */
+  async _setData (peerId, data, { persist = true, emit = true } = {}) {
+    const b58key = peerId.toB58String()
+
+    // Store data in memory
+    this.data.set(b58key, data)
+    this._setPeerId(peerId)
+
+    // Emit event
+    emit && this._ps.emit(this.eventName, {
+      peerId,
+      [this.eventProperty]: this.eventTransformer(data)
+    })
+
+    // Add to Persistence datastore
+    persist && await this._persistData(peerId, data)
+  }
+
+  /**
+   * Persist data on the datastore
+   * @private
+   * @param {PeerId} peerId peerId of the data to persist
+   * @param {Array<*>} data data to persist
+   * @return {Promise<void>}
+   */
+  async _persistData (peerId, data) {
+    if (!this._ps._datastore || !this._ps._enabledPersistance) {
+      return
+    }
+
+    const b32key = peerId.toString()
+    const k = `${this.dsPrefix}${b32key}${this.dsSuffix}`
+    try {
+      const value = this.protoBuf.encode(this.dsSetTransformer(data))
+
+      await this._ps._datastore.put(new Key(k), value)
+    } catch (err) {
+      log.error(err)
+    }
+  }
+
   /**
    * Set known data of a provided peer.
    * @param {PeerId} peerId
@@ -75,9 +197,17 @@ class Book {
       [this.eventProperty]: []
     })
 
+    // Update Persistence datastore
+    this._persistData(peerId, [])
+
     return true
   }
 
+  /**
+   * Set PeerId into peerStore datastructure.
+   * @private
+   * @param {PeerId} peerId
+   */
   _setPeerId (peerId) {
     if (!this._ps.peerIds.get(peerId)) {
       this._ps.peerIds.set(peerId.toB58String(), peerId)