@libp2p/kad-dht 12.0.1 → 12.0.2

package/src/kad-dht.ts

@@ -1,7 +1,5 @@
 import { CodeError, CustomEvent, TypedEventEmitter, contentRoutingSymbol, peerDiscoverySymbol, peerRoutingSymbol } from '@libp2p/interface'
 import drain from 'it-drain'
-import map from 'it-map'
-import parallel from 'it-parallel'
 import pDefer from 'p-defer'
 import { PROTOCOL } from './constants.js'
 import { ContentFetching } from './content-fetching/index.js'
@@ -22,42 +20,17 @@ import {
   removePrivateAddressesMapper
 } from './utils.js'
 import type { KadDHTComponents, KadDHTInit, Validators, Selectors, KadDHT as KadDHTInterface, QueryEvent, PeerInfoMapper } from './index.js'
-import type { AbortOptions, ContentRouting, Logger, PeerDiscovery, PeerDiscoveryEvents, PeerId, PeerInfo, PeerRouting, RoutingOptions, Startable } from '@libp2p/interface'
+import type { ContentRouting, Logger, PeerDiscovery, PeerDiscoveryEvents, PeerId, PeerInfo, PeerRouting, RoutingOptions, Startable } from '@libp2p/interface'
 import type { CID } from 'multiformats/cid'
 
-async function * ensurePeerInfoHasMultiaddrs (source: AsyncGenerator<PeerInfo>, peerRouting: PeerRouting, log: Logger, options: AbortOptions = {}): AsyncGenerator<() => Promise<PeerInfo | undefined>, void, undefined> {
-  yield * map(source, prov => {
-    return async () => {
-      if (prov.multiaddrs.length > 0) {
-        return prov
-      }
-
-      try {
-        return await peerRouting.findPeer(prov.id, {
-          ...options,
-          useCache: false
-        })
-      } catch (err) {
-        log.error('could not find peer', err)
-      }
-    }
-  })
-}
-
 /**
  * Wrapper class to convert events into returned values
  */
 class DHTContentRouting implements ContentRouting {
   private readonly dht: KadDHTInterface
-  private readonly peerInfoMapper: PeerInfoMapper
-  private readonly peerRouting: PeerRouting
-  private readonly log: Logger
 
-  constructor (dht: KadDHTInterface, peerInfoMapper: PeerInfoMapper, peerRouting: PeerRouting, log: Logger) {
+  constructor (dht: KadDHTInterface) {
     this.dht = dht
-    this.peerInfoMapper = peerInfoMapper
-    this.peerRouting = peerRouting
-    this.log = log
   }
 
   async provide (cid: CID, options: RoutingOptions = {}): Promise<void> {
@@ -65,27 +38,11 @@ class DHTContentRouting implements ContentRouting {
   }
 
   async * findProviders (cid: CID, options: RoutingOptions = {}): AsyncGenerator<PeerInfo, void, undefined> {
-    const self = this
-    const source = async function * (): AsyncGenerator<PeerInfo, void, undefined> {
-      for await (const event of self.dht.findProviders(cid, options)) {
-        if (event.name === 'PROVIDER') {
-          yield * event.providers
-        }
+    for await (const event of this.dht.findProviders(cid, options)) {
+      if (event.name === 'PROVIDER') {
+        yield * event.providers
       }
     }
-    for await (let peerInfo of parallel(ensurePeerInfoHasMultiaddrs(source(), this.peerRouting, this.log, options))) {
-      if (peerInfo == null) {
-        continue
-      }
-
-      peerInfo = this.peerInfoMapper(peerInfo)
-
-      if (peerInfo.multiaddrs.length === 0) {
-        continue
-      }
-
-      yield peerInfo
-    }
   }
 
   async put (key: Uint8Array, value: Uint8Array, options?: RoutingOptions): Promise<void> {
@@ -108,23 +65,15 @@ class DHTContentRouting implements ContentRouting {
  */
 class DHTPeerRouting implements PeerRouting {
   private readonly dht: KadDHTInterface
-  private readonly peerInfoMapper: PeerInfoMapper
-  private readonly log: Logger
 
-  constructor (dht: KadDHTInterface, peerInfoMapper: PeerInfoMapper, log: Logger) {
+  constructor (dht: KadDHTInterface) {
     this.dht = dht
-    this.peerInfoMapper = peerInfoMapper
-    this.log = log
   }
 
   async findPeer (peerId: PeerId, options: RoutingOptions = {}): Promise<PeerInfo> {
     for await (const event of this.dht.findPeer(peerId, options)) {
       if (event.name === 'FINAL_PEER') {
-        const peer = this.peerInfoMapper(event.peer)
-
-        if (peer.multiaddrs.length > 0) {
-          return event.peer
-        }
+        return event.peer
       }
     }
 
@@ -132,27 +81,10 @@ class DHTPeerRouting implements PeerRouting {
   }
 
   async * getClosestPeers (key: Uint8Array, options: RoutingOptions = {}): AsyncIterable<PeerInfo> {
-    const self = this
-    const source = async function * (): AsyncGenerator<PeerInfo, void, undefined> {
-      for await (const event of self.dht.getClosestPeers(key, options)) {
-        if (event.name === 'FINAL_PEER') {
-          yield event.peer
-        }
-      }
-    }
-
-    for await (let peerInfo of parallel(ensurePeerInfoHasMultiaddrs(source(), this, this.log, options))) {
-      if (peerInfo == null) {
-        continue
-      }
-
-      peerInfo = this.peerInfoMapper(peerInfo)
-
-      if (peerInfo.multiaddrs.length === 0) {
-        continue
+    for await (const event of this.dht.getClosestPeers(key, options)) {
+      if (event.name === 'FINAL_PEER') {
+        yield event.peer
       }
-
-      yield peerInfo
     }
   }
 }
@@ -347,8 +279,8 @@ export class KadDHT extends TypedEventEmitter<PeerDiscoveryEvents> implements Ka
       })
     })
 
-    this.dhtPeerRouting = new DHTPeerRouting(this, this.peerInfoMapper, this.log)
-    this.dhtContentRouting = new DHTContentRouting(this, this.peerInfoMapper, this.dhtPeerRouting, this.log)
+    this.dhtPeerRouting = new DHTPeerRouting(this)
+    this.dhtContentRouting = new DHTContentRouting(this)
 
     // if client mode has not been explicitly specified, auto-switch to server
     // mode when the node's peer data is updated with publicly dialable

package/src/query/manager.ts

@@ -1,7 +1,8 @@
-import { AbortError, TypedEventEmitter, CustomEvent, setMaxListeners } from '@libp2p/interface'
+import { TypedEventEmitter, CustomEvent, setMaxListeners } from '@libp2p/interface'
 import { PeerSet } from '@libp2p/peer-collections'
 import { anySignal } from 'any-signal'
 import merge from 'it-merge'
+import { raceSignal } from 'race-signal'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import {
   ALPHA, K, DEFAULT_QUERY_TIMEOUT
@@ -127,7 +128,16 @@ export class QueryManager implements Startable {
       }
     }
 
-    const signal = anySignal([this.shutDownController.signal, options.signal])
+    // if the user breaks out of a for..await of loop iterating over query
+    // results we need to cancel any in-flight network requests
+    const queryEarlyExitController = new AbortController()
+    setMaxListeners(Infinity, queryEarlyExitController.signal)
+
+    const signal = anySignal([
+      this.shutDownController.signal,
+      queryEarlyExitController.signal,
+      options.signal
+    ])
 
     // this signal will get listened to for every invocation of queryFunc
     // so make sure we don't make a lot of noise in the logs
@@ -138,19 +148,13 @@ export class QueryManager implements Startable {
     // query a subset of peers up to `kBucketSize / 2` in length
     const startTime = Date.now()
     const cleanUp = new TypedEventEmitter<CleanUpEvents>()
+    let queryFinished = false
 
     try {
       if (options.isSelfQuery !== true && this.initialQuerySelfHasRun != null) {
         log('waiting for initial query-self query before continuing')
 
-        await Promise.race([
-          new Promise((resolve, reject) => {
-            signal.addEventListener('abort', () => {
-              reject(new AbortError('Query was aborted before self-query ran'))
-            })
-          }),
-          this.initialQuerySelfHasRun.promise
-        ])
+        await raceSignal(this.initialQuerySelfHasRun.promise, signal)
 
         this.initialQuerySelfHasRun = undefined
       }
@@ -192,12 +196,14 @@ export class QueryManager implements Startable {
 
       // Execute the query along each disjoint path and yield their results as they become available
       for await (const event of merge(...paths)) {
-        yield event
-
         if (event.name === 'QUERY_ERROR') {
-          log('error', event.error)
+          log.error('query error', event.error)
         }
+
+        yield event
       }
+
+      queryFinished = true
     } catch (err: any) {
       if (!this.running && err.code === 'ERR_QUERY_ABORTED') {
         // ignore query aborted errors that were thrown during query manager shutdown
@@ -205,6 +211,11 @@ export class QueryManager implements Startable {
         throw err
       }
     } finally {
+      if (!queryFinished) {
+        log('query exited early')
+        queryEarlyExitController.abort()
+      }
+
       signal.clear()
 
       this.queries--

package/src/routing-table/index.ts

@@ -1,6 +1,6 @@
 import { CodeError, TypedEventEmitter } from '@libp2p/interface'
 import { PeerSet } from '@libp2p/peer-collections'
-import { PeerJobQueue } from '@libp2p/utils/peer-job-queue'
+import { PeerQueue } from '@libp2p/utils/peer-queue'
 import { pbStream } from 'it-protobuf-stream'
 import { Message, MessageType } from '../message/dht.js'
 import * as utils from '../utils.js'
@@ -44,7 +44,7 @@ export interface RoutingTableEvents {
 export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implements Startable {
   public kBucketSize: number
   public kb?: KBucket
-  public pingQueue: PeerJobQueue
+  public pingQueue: PeerQueue<boolean>
 
   private readonly log: Logger
   private readonly components: RoutingTableComponents
@@ -56,8 +56,6 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
   private readonly tagValue: number
   private readonly metrics?: {
     routingTableSize: Metric
-    pingQueueSize: Metric
-    pingRunning: Metric
   }
 
   constructor (components: RoutingTableComponents, init: RoutingTableInit) {
@@ -75,23 +73,18 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
     this.tagName = tagName ?? KAD_CLOSE_TAG_NAME
     this.tagValue = tagValue ?? KAD_CLOSE_TAG_VALUE
 
-    const updatePingQueueSizeMetric = (): void => {
-      this.metrics?.pingQueueSize.update(this.pingQueue.size)
-      this.metrics?.pingRunning.update(this.pingQueue.pending)
-    }
-
-    this.pingQueue = new PeerJobQueue({ concurrency: this.pingConcurrency })
-    this.pingQueue.addListener('add', updatePingQueueSizeMetric)
-    this.pingQueue.addListener('next', updatePingQueueSizeMetric)
-    this.pingQueue.addListener('error', err => {
-      this.log.error('error pinging peer', err)
+    this.pingQueue = new PeerQueue({
+      concurrency: this.pingConcurrency,
+      metricName: `${logPrefix.replaceAll(':', '_')}_ping_queue`,
+      metrics: this.components.metrics
+    })
+    this.pingQueue.addEventListener('error', evt => {
+      this.log.error('error pinging peer', evt.detail)
     })
 
     if (this.components.metrics != null) {
       this.metrics = {
-        routingTableSize: this.components.metrics.registerMetric(`${logPrefix.replaceAll(':', '_')}_routing_table_size`),
-        pingQueueSize: this.components.metrics.registerMetric(`${logPrefix.replaceAll(':', '_')}_ping_queue_size`),
-        pingRunning: this.components.metrics.registerMetric(`${logPrefix.replaceAll(':', '_')}_ping_running`)
+        routingTableSize: this.components.metrics.registerMetric(`${logPrefix.replaceAll(':', '_')}_routing_table_size`)
       }
     }
   }
@@ -204,8 +197,10 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
     const results = await Promise.all(
       oldContacts.map(async oldContact => {
         // if a previous ping wants us to ping this contact, re-use the result
-        if (this.pingQueue.hasJob(oldContact.peer)) {
-          return this.pingQueue.joinJob(oldContact.peer)
+        const pingJob = this.pingQueue.find(oldContact.peer)
+
+        if (pingJob != null) {
+          return pingJob.join()
         }
 
         return this.pingQueue.add(async () => {