@libp2p/circuit-relay-v2 2.1.2 → 2.1.3-0d326d102

package/src/transport/listener.ts

@@ -14,7 +14,7 @@ export interface CircuitRelayTransportListenerComponents {
 
 class CircuitRelayTransportListener extends TypedEventEmitter<ListenerEvents> implements Listener {
   private readonly connectionManager: ConnectionManager
-  private readonly relayStore: ReservationStore
+  private readonly reservationStore: ReservationStore
   private readonly listeningAddrs: PeerMap<Multiaddr[]>
   private readonly log: Logger
 
@@ -23,15 +23,26 @@ class CircuitRelayTransportListener extends TypedEventEmitter<ListenerEvents> im
 
     this.log = components.logger.forComponent('libp2p:circuit-relay:transport:listener')
     this.connectionManager = components.connectionManager
-    this.relayStore = components.relayStore
+    this.reservationStore = components.relayStore
     this.listeningAddrs = new PeerMap()
 
     // remove listening addrs when a relay is removed
-    this.relayStore.addEventListener('relay:removed', this._onRemoveRelayPeer)
+    this.reservationStore.addEventListener('relay:removed', this._onRemoveRelayPeer)
   }
 
   _onRemoveRelayPeer = (evt: CustomEvent<PeerId>): void => {
-    this.#removeRelayPeer(evt.detail)
+    const had = this.listeningAddrs.has(evt.detail)
+
+    this.log('relay peer removed %p - had reservation', evt.detail, had)
+
+    if (!had) {
+      return
+    }
+
+    this.listeningAddrs.delete(evt.detail)
+
+    // announce listen addresses change
+    this.safeDispatchEvent('listening')
   }
 
   async listen (addr: Multiaddr): Promise<void> {
@@ -41,14 +52,14 @@ class CircuitRelayTransportListener extends TypedEventEmitter<ListenerEvents> im
     const relayAddr = addr.decapsulate('/p2p-circuit')
     const relayConn = await this.connectionManager.openConnection(relayAddr)
 
-    if (!this.relayStore.hasReservation(relayConn.remotePeer)) {
+    if (!this.reservationStore.hasReservation(relayConn.remotePeer)) {
       this.log('making reservation on peer %p', relayConn.remotePeer)
       // addRelay calls transportManager.listen which calls this listen method
-      await this.relayStore.addRelay(relayConn.remotePeer, 'configured')
+      await this.reservationStore.addRelay(relayConn.remotePeer, 'configured')
       return
     }
 
-    const reservation = this.relayStore.getReservation(relayConn.remotePeer)
+    const reservation = this.reservationStore.getReservation(relayConn.remotePeer)
 
     if (reservation == null) {
       throw new ListenError('Did not have reservation after making reservation')
@@ -60,11 +71,11 @@ class CircuitRelayTransportListener extends TypedEventEmitter<ListenerEvents> im
     }
 
     // add all addresses from the relay reservation
-    this.listeningAddrs.set(relayConn.remotePeer, reservation.addrs.map(buf => {
-      return multiaddr(buf).encapsulate('/p2p-circuit')
-    }))
+    this.listeningAddrs.set(relayConn.remotePeer, reservation.addrs
+      .map(buf => multiaddr(buf).encapsulate('/p2p-circuit'))
+    )
 
-    this.safeDispatchEvent('listening', {})
+    this.safeDispatchEvent('listening')
   }
 
   getAddrs (): Multiaddr[] {
@@ -72,22 +83,14 @@ class CircuitRelayTransportListener extends TypedEventEmitter<ListenerEvents> im
   }
 
   async close (): Promise<void> {
+    await this.reservationStore.cancelReservations()
+    this.listeningAddrs.clear()
 
-  }
-
-  #removeRelayPeer (peerId: PeerId): void {
-    const had = this.listeningAddrs.has(peerId)
-
-    this.log('relay peer removed %p - had reservation', peerId, had)
+    // remove listener
+    this.reservationStore.removeEventListener('relay:removed', this._onRemoveRelayPeer)
 
-    this.listeningAddrs.delete(peerId)
-
-    if (had) {
-      this.log.trace('removing relay event listener for peer %p', peerId)
-      this.relayStore.removeEventListener('relay:removed', this._onRemoveRelayPeer)
-      // Announce listen addresses change
-      this.safeDispatchEvent('close', {})
-    }
+    // announce listen addresses change
+    this.safeDispatchEvent('close')
   }
 }
 

package/src/transport/reservation-store.ts

@@ -4,12 +4,11 @@ import { createBloomFilter } from '@libp2p/utils/filters'
 import { PeerQueue } from '@libp2p/utils/peer-queue'
 import { multiaddr } from '@multiformats/multiaddr'
 import { pbStream } from 'it-protobuf-stream'
-import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
-import { DEFAULT_MAX_RESERVATION_QUEUE_LENGTH, DEFAULT_RESERVATION_COMPLETION_TIMEOUT, DEFAULT_RESERVATION_CONCURRENCY, RELAY_TAG, RELAY_V2_HOP_CODEC } from '../constants.js'
+import { DEFAULT_MAX_RESERVATION_QUEUE_LENGTH, DEFAULT_RESERVATION_COMPLETION_TIMEOUT, DEFAULT_RESERVATION_CONCURRENCY, KEEP_ALIVE_TAG, RELAY_TAG, RELAY_V2_HOP_CODEC } from '../constants.js'
 import { HopMessage, Status } from '../pb/index.js'
 import { getExpirationMilliseconds } from '../utils.js'
 import type { Reservation } from '../pb/index.js'
-import type { TypedEventTarget, Libp2pEvents, AbortOptions, ComponentLogger, Logger, Connection, PeerId, PeerStore, Startable, Metrics } from '@libp2p/interface'
+import type { TypedEventTarget, Libp2pEvents, AbortOptions, ComponentLogger, Logger, Connection, PeerId, PeerStore, Startable, Metrics, Peer } from '@libp2p/interface'
 import type { ConnectionManager, TransportManager } from '@libp2p/interface-internal'
 import type { Filter } from '@libp2p/utils/filters'
 
@@ -22,7 +21,7 @@ const REFRESH_TIMEOUT = (60 * 1000) * 5
 // minimum duration before which a reservation must not be refreshed
 const REFRESH_TIMEOUT_MIN = 30 * 1000
 
-export interface RelayStoreComponents {
+export interface ReservationStoreComponents {
   peerId: PeerId
   connectionManager: ConnectionManager
   transportManager: TransportManager
@@ -32,7 +31,7 @@ export interface RelayStoreComponents {
   metrics?: Metrics
 }
 
-export interface RelayStoreInit {
+export interface ReservationStoreInit {
   /**
    * Multiple relays may be discovered simultaneously - to prevent listening
    * on too many relays, this value controls how many to attempt to reserve a
@@ -71,6 +70,11 @@ interface RelayEntry {
   timeout: ReturnType<typeof setTimeout>
   type: RelayType
   reservation: Reservation
+
+  /**
+   * Stores the id of the connection we have to the relay
+   */
+  connection: string
 }
 
 export interface ReservationStoreEvents {
@@ -94,7 +98,7 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
   private readonly log: Logger
   private readonly relayFilter: Filter
 
-  constructor (components: RelayStoreComponents, init?: RelayStoreInit) {
+  constructor (components: ReservationStoreComponents, init?: ReservationStoreInit) {
     super()
 
     this.log = components.logger.forComponent('libp2p:circuit-relay:transport:reservation-store')
@@ -117,11 +121,21 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
       metrics: components.metrics
     })
 
-    // When a peer disconnects, if we had a reservation on that peer
-    // remove the reservation and multiaddr and maybe trigger search
-    // for new relays
-    this.events.addEventListener('peer:disconnect', (evt) => {
-      this.#removeRelay(evt.detail)
+    // reservations are only valid while we are still connected to the relay.
+    // if we had a reservation opened via that connection, remove it and maybe
+    // trigger a search for new relays
+    this.events.addEventListener('connection:close', (evt) => {
+      const reservation = [...this.reservations.values()]
+        .find(reservation => reservation.connection === evt.detail.id)
+
+      if (reservation == null) {
+        return
+      }
+
+      this.#removeReservation(evt.detail.remotePeer, reservation)
+        .catch(err => {
+          this.log('could not remove relay %p - %e', evt.detail, err)
+        })
     })
   }
 
@@ -134,10 +148,37 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
   }
 
   afterStart (): void {
-    if (this.reservations.size < this.maxDiscoveredRelays) {
-      this.log('not enough relays %d/%d', this.reservations.size, this.maxDiscoveredRelays)
-      this.safeDispatchEvent('relay:not-enough-relays', {})
-    }
+    // remove old relay tags
+    void Promise.resolve()
+      .then(async () => {
+        const relayPeers: Peer[] = await this.peerStore.all({
+          filters: [(peer) => {
+            return peer.tags.has(RELAY_TAG)
+          }]
+        })
+
+        this.log('removing tag from %d old relays', relayPeers.length)
+
+        // remove old relay tag and redial
+        await Promise.all(
+          relayPeers.map(async peer => {
+            await this.peerStore.merge(peer.id, {
+              tags: {
+                [RELAY_TAG]: undefined,
+                [KEEP_ALIVE_TAG]: undefined
+              }
+            })
+          })
+        )
+
+        if (this.reservations.size < this.maxDiscoveredRelays) {
+          this.log('not enough relays %d/%d', this.reservations.size, this.maxDiscoveredRelays)
+          this.safeDispatchEvent('relay:not-enough-relays', {})
+        }
+      })
+      .catch(err => {
+        this.log.error(err)
+      })
   }
 
   stop (): void {
@@ -157,26 +198,26 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
    */
   async addRelay (peerId: PeerId, type: RelayType): Promise<void> {
     if (this.peerId.equals(peerId)) {
-      this.log('not trying to use self as relay')
+      this.log.trace('not trying to use self as relay')
       return
     }
 
     if (this.reserveQueue.size > this.maxReservationQueueLength) {
-      this.log('not adding potential relay peer %p as the queue is full', peerId)
+      this.log.trace('not adding potential relay peer %p as the queue is full', peerId)
       return
     }
 
     if (this.reserveQueue.has(peerId)) {
-      this.log('potential relay peer %p is already in the reservation queue', peerId)
+      this.log.trace('potential relay peer %p is already in the reservation queue', peerId)
       return
     }
 
     if (this.relayFilter.has(peerId.toMultihash().bytes)) {
-      this.log('potential relay peer %p has failed previously, not trying again', peerId)
+      this.log.trace('potential relay peer %p has failed previously, not trying again', peerId)
       return
     }
 
-    this.log('try to reserve relay slot with %p', peerId)
+    this.log.trace('try to reserve relay slot with %p', peerId)
 
     await this.reserveQueue.add(async () => {
       const start = Date.now()
@@ -186,13 +227,13 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
         const existingReservation = this.reservations.get(peerId)
 
         if (existingReservation != null) {
-          if (getExpirationMilliseconds(existingReservation.reservation.expire) > REFRESH_WINDOW) {
-            this.log('already have reservation on relay peer %p and it expires in more than 10 minutes', peerId)
+          if (this.connectionManager.getConnections(peerId).map(conn => conn.id).includes(existingReservation.connection) && getExpirationMilliseconds(existingReservation.reservation.expire) > REFRESH_WINDOW) {
+            this.log('already have relay reservation with %p but we are still connected and it does not expire soon', peerId)
             return
           }
 
-          clearTimeout(existingReservation.timeout)
-          this.reservations.delete(peerId)
+          this.log('already have relay reservation with %p but the original connection is no longer open', peerId)
+          await this.#removeReservation(peerId, existingReservation)
         }
 
         if (type === 'discovered' && [...this.reservations.values()].reduce((acc, curr) => {
@@ -202,7 +243,7 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
 
           return acc
         }, 0) >= this.maxDiscoveredRelays) {
-          this.log('already have enough discovered relays')
+          this.log.trace('already have enough discovered relays')
           return
         }
 
@@ -240,7 +281,8 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
         this.reservations.set(peerId, {
           timeout,
           reservation,
-          type
+          type,
+          connection: connection.id
         })
 
         // ensure we don't close the connection to the relay
@@ -249,6 +291,10 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
             [RELAY_TAG]: {
               value: 1,
               ttl: expiration
+            },
+            [KEEP_ALIVE_TAG]: {
+              value: 1,
+              ttl: expiration
             }
           }
         })
@@ -292,6 +338,14 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
     return this.reservations.size
   }
 
+  async cancelReservations (): Promise<void> {
+    await Promise.all(
+      [...this.reservations.entries()].map(async ([peerId, reservation]) => {
+        await this.#removeReservation(peerId, reservation)
+      })
+    )
+  }
+
   async #createReservation (connection: Connection, options: AbortOptions): Promise<Reservation> {
     options.signal?.throwIfAborted()
 
@@ -314,24 +368,31 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
       }
     }
 
-    if (response.status === Status.OK && (response.reservation != null)) {
+    if (response.status === Status.OK && response.reservation != null) {
       // check that the returned relay has the relay address - this can be
       // omitted when requesting a reservation from a go-libp2p relay we
       // already have a reservation on
-      let hasRelayAddress = false
-      const relayAddressBytes = connection.remoteAddr.bytes
+      const addresses = new Set<string>()
+      addresses.add(connection.remoteAddr.toString())
 
       for (const buf of response.reservation.addrs) {
-        if (uint8ArrayEquals(relayAddressBytes, buf)) {
-          hasRelayAddress = true
-          break
+        let ma = multiaddr(buf)
+
+        if (ma.getPeerId() == null) {
+          ma = ma.encapsulate(`/p2p/${connection.remotePeer}`)
         }
-      }
 
-      if (!hasRelayAddress) {
-        response.reservation.addrs.push(relayAddressBytes)
+        // TODO: workaround for https://github.com/libp2p/go-libp2p/issues/3003
+        ma = multiaddr(ma.toString().replace(
+          `/p2p/${connection.remotePeer}/p2p/${connection.remotePeer}`,
+          `/p2p/${connection.remotePeer}`
+        ))
+
+        addresses.add(ma.toString())
       }
 
+      response.reservation.addrs = [...addresses].map(str => multiaddr(str).bytes)
+
       return response.reservation
     }
 
@@ -344,18 +405,19 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
   /**
    * Remove listen relay
    */
-  #removeRelay (peerId: PeerId): void {
-    const existingReservation = this.reservations.get(peerId)
-
-    if (existingReservation == null) {
-      return
-    }
-
-    this.log('connection to relay %p closed, removing reservation from local store', peerId)
-
-    clearTimeout(existingReservation.timeout)
+  async #removeReservation (peerId: PeerId, reservation: RelayEntry): Promise<void> {
+    this.log('removing relay reservation with %p from local store', peerId)
+    clearTimeout(reservation.timeout)
     this.reservations.delete(peerId)
 
+    // untag the relay
+    await this.peerStore.merge(peerId, {
+      tags: {
+        [RELAY_TAG]: undefined,
+        [KEEP_ALIVE_TAG]: undefined
+      }
+    })
+
     this.safeDispatchEvent('relay:removed', { detail: peerId })
 
     if (this.reservations.size < this.maxDiscoveredRelays) {

package/dist/typedoc-urls.json

@@ -1,23 +0,0 @@
-{
-  "codec": "https://libp2p.github.io/js-libp2p/functions/_libp2p_circuit_relay_v2.Limit.codec.html",
-  "decode": "https://libp2p.github.io/js-libp2p/functions/_libp2p_circuit_relay_v2.Limit.decode.html",
-  "encode": "https://libp2p.github.io/js-libp2p/functions/_libp2p_circuit_relay_v2.Limit.encode.html",
-  "CircuitRelayServerComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_circuit_relay_v2.CircuitRelayServerComponents.html",
-  "CircuitRelayServerInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_circuit_relay_v2.CircuitRelayServerInit.html",
-  "CircuitRelayService": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_circuit_relay_v2.CircuitRelayService.html",
-  ".:CircuitRelayService": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_circuit_relay_v2.CircuitRelayService.html",
-  "CircuitRelayServiceEvents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_circuit_relay_v2.CircuitRelayServiceEvents.html",
-  ".:CircuitRelayServiceEvents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_circuit_relay_v2.CircuitRelayServiceEvents.html",
-  "CircuitRelayTransportComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_circuit_relay_v2.CircuitRelayTransportComponents.html",
-  "CircuitRelayTransportInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_circuit_relay_v2.CircuitRelayTransportInit.html",
-  "Limit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_circuit_relay_v2.Limit-1.html",
-  "RelayDiscoveryComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_circuit_relay_v2.RelayDiscoveryComponents.html",
-  "RelayReservation": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_circuit_relay_v2.RelayReservation.html",
-  ".:RelayReservation": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_circuit_relay_v2.RelayReservation.html",
-  "RelayStoreInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_circuit_relay_v2.RelayStoreInit.html",
-  "ReservationStoreInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_circuit_relay_v2.ReservationStoreInit.html",
-  "RELAY_V2_HOP_CODEC": "https://libp2p.github.io/js-libp2p/variables/_libp2p_circuit_relay_v2.RELAY_V2_HOP_CODEC.html",
-  "RELAY_V2_STOP_CODEC": "https://libp2p.github.io/js-libp2p/variables/_libp2p_circuit_relay_v2.RELAY_V2_STOP_CODEC.html",
-  "circuitRelayServer": "https://libp2p.github.io/js-libp2p/functions/_libp2p_circuit_relay_v2.circuitRelayServer.html",
-  "circuitRelayTransport": "https://libp2p.github.io/js-libp2p/functions/_libp2p_circuit_relay_v2.circuitRelayTransport.html"
-}