feat: registrar (#471)

* feat: peer-store v0

* feat: registrar

* chore: apply suggestions from code review

Co-Authored-By: Jacob Heun <jacobheun@gmail.com>

* chore: address review

* chore: support multiple conns

* chore: address review

* fix: no remote peer from topology on disconnect

src/registrar.js

@@ -0,0 +1,139 @@
+'use strict'
+
+const assert = require('assert')
+const debug = require('debug')
+const log = debug('libp2p:peer-store')
+log.error = debug('libp2p:peer-store:error')
+
+const { Connection } = require('libp2p-interfaces/src/connection')
+const PeerInfo = require('peer-info')
+const Toplogy = require('./connection-manager/topology')
+
+/**
+ * Responsible for notifying registered protocols of events in the network.
+ */
+class Registrar {
+  /**
+   * @param {Object} props
+   * @param {PeerStore} props.peerStore
+   * @constructor
+   */
+  constructor ({ peerStore }) {
+    this.peerStore = peerStore
+
+    /**
+     * Map of connections per peer
+     * TODO: this should be handled by connectionManager
+     * @type {Map<string, Array<conn>>}
+     */
+    this.connections = new Map()
+
+    /**
+     * Map of topologies
+     *
+     * @type {Map<string, object>}
+     */
+    this.topologies = new Map()
+
+    this._handle = undefined
+  }
+
+  get handle () {
+    return this._handle
+  }
+
+  set handle (handle) {
+    this._handle = handle
+  }
+
+  /**
+   * Add a new connected peer to the record
+   * TODO: this should live in the ConnectionManager
+   * @param {PeerInfo} peerInfo
+   * @param {Connection} conn
+   * @returns {void}
+   */
+  onConnect (peerInfo, conn) {
+    assert(PeerInfo.isPeerInfo(peerInfo), 'peerInfo must be an instance of peer-info')
+    assert(Connection.isConnection(conn), 'conn must be an instance of interface-connection')
+
+    const id = peerInfo.id.toB58String()
+    const storedConn = this.connections.get(id)
+
+    if (storedConn) {
+      storedConn.push(conn)
+    } else {
+      this.connections.set(id, [conn])
+    }
+  }
+
+  /**
+   * Remove a disconnected peer from the record
+   * TODO: this should live in the ConnectionManager
+   * @param {PeerInfo} peerInfo
+   * @param {Connection} connection
+   * @param {Error} [error]
+   * @returns {void}
+   */
+  onDisconnect (peerInfo, connection, error) {
+    assert(PeerInfo.isPeerInfo(peerInfo), 'peerInfo must be an instance of peer-info')
+
+    const id = peerInfo.id.toB58String()
+    let storedConn = this.connections.get(id)
+
+    if (storedConn && storedConn.length > 1) {
+      storedConn = storedConn.filter((conn) => conn.id === connection.id)
+    } else if (storedConn) {
+      for (const [, topology] of this.topologies) {
+        topology.disconnect(peerInfo, error)
+      }
+
+      this.connections.delete(peerInfo.id.toB58String())
+    }
+  }
+
+  /**
+   * Get a connection with a peer.
+   * @param {PeerInfo} peerInfo
+   * @returns {Connection}
+   */
+  getConnection (peerInfo) {
+    assert(PeerInfo.isPeerInfo(peerInfo), 'peerInfo must be an instance of peer-info')
+
+    // TODO: what should we return
+    return this.connections.get(peerInfo.id.toB58String())[0]
+  }
+
+  /**
+   * Register handlers for a set of multicodecs given
+   * @param {Object} topologyProps properties for topology
+   * @param {Array<string>|string} topologyProps.multicodecs
+   * @param {Object} topologyProps.handlers
+   * @param {function} topologyProps.handlers.onConnect
+   * @param {function} topologyProps.handlers.onDisconnect
+   * @return {string} registrar identifier
+   */
+  register (topologyProps) {
+    // Create multicodec topology
+    const id = (parseInt(Math.random() * 1e9)).toString(36) + Date.now()
+    const topology = new Toplogy(topologyProps)
+
+    this.topologies.set(id, topology)
+
+    // Set registrar
+    topology.registrar = this
+
+    return id
+  }
+
+  /**
+   * Unregister topology.
+   * @param {string} id registrar identifier
+   * @return {boolean} unregistered successfully
+   */
+  unregister (id) {
+    return this.topologies.delete(id)
+  }
+}
+
+module.exports = Registrar