@libp2p/kad-dht 15.0.2 → 15.1.0

package/src/peer-routing/index.ts

@@ -3,7 +3,6 @@ import { InvalidPublicKeyError, NotFoundError } from '@libp2p/interface'
 import { peerIdFromPublicKey, peerIdFromMultihash } from '@libp2p/peer-id'
 import { Libp2pRecord } from '@libp2p/record'
 import * as Digest from 'multiformats/hashes/digest'
-import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { xor as uint8ArrayXor } from 'uint8arrays/xor'
 import { xorCompare as uint8ArrayXorCompare } from 'uint8arrays/xor-compare'
 import { QueryError, InvalidRecordError } from '../errors.js'
@@ -18,17 +17,19 @@ import { verifyRecord } from '../record/validators.js'
 import { convertBuffer, convertPeerId, keyForPublicKey } from '../utils.js'
 import type { DHTRecord, FinalPeerEvent, QueryEvent, Validators } from '../index.js'
 import type { Message } from '../message/dht.js'
-import type { Network } from '../network.js'
+import type { Network, SendMessageOptions } from '../network.js'
 import type { QueryManager, QueryOptions } from '../query/manager.js'
 import type { QueryFunc } from '../query/types.js'
 import type { RoutingTable } from '../routing-table/index.js'
 import type { ComponentLogger, Logger, Metrics, PeerId, PeerInfo, PeerStore, RoutingOptions } from '@libp2p/interface'
+import type { ConnectionManager } from '@libp2p/interface-internal'
 
 export interface PeerRoutingComponents {
   peerId: PeerId
   peerStore: PeerStore
   logger: ComponentLogger
   metrics?: Metrics
+  connectionManager: ConnectionManager
 }
 
 export interface PeerRoutingInit {
@@ -45,16 +46,14 @@ export class PeerRouting {
   private readonly network: Network
   private readonly validators: Validators
   private readonly queryManager: QueryManager
-  private readonly peerStore: PeerStore
-  private readonly peerId: PeerId
+  private readonly components: PeerRoutingComponents
 
   constructor (components: PeerRoutingComponents, init: PeerRoutingInit) {
     this.routingTable = init.routingTable
     this.network = init.network
     this.validators = init.validators
     this.queryManager = init.queryManager
-    this.peerStore = components.peerStore
-    this.peerId = components.peerId
+    this.components = components
     this.log = components.logger.forComponent(`${init.logPrefix}:peer-routing`)
 
     this.findPeer = components.metrics?.traceFunction('libp2p.kadDHT.findPeer', this.findPeer.bind(this), {
@@ -77,7 +76,7 @@ export class PeerRouting {
       this.log('findPeerLocal found %p in routing table', peer)
 
       try {
-        peerData = await this.peerStore.get(p)
+        peerData = await this.components.peerStore.get(p)
       } catch (err: any) {
         if (err.name !== 'NotFoundError') {
           throw err
@@ -87,7 +86,7 @@ export class PeerRouting {
 
     if (peerData == null) {
       try {
-        peerData = await this.peerStore.get(peer)
+        peerData = await this.components.peerStore.get(peer)
       } catch (err: any) {
         if (err.name !== 'NotFoundError') {
           throw err
@@ -110,7 +109,7 @@ export class PeerRouting {
   /**
    * Get a value via rpc call for the given parameters
    */
-  async * _getValueSingle (peer: PeerId, key: Uint8Array, options: RoutingOptions = {}): AsyncGenerator<QueryEvent> {
+  async * _getValueSingle (peer: PeerId, key: Uint8Array, options: SendMessageOptions): AsyncGenerator<QueryEvent> {
     const msg: Partial<Message> = {
       type: MessageType.GET_VALUE,
       key
@@ -124,8 +123,17 @@ export class PeerRouting {
    */
   async * getPublicKeyFromNode (peer: PeerId, options: RoutingOptions = {}): AsyncGenerator<QueryEvent> {
     const pkKey = keyForPublicKey(peer)
+    const path = {
+      index: -1,
+      queued: 0,
+      running: 0,
+      total: 0
+    }
 
-    for await (const event of this._getValueSingle(peer, pkKey, options)) {
+    for await (const event of this._getValueSingle(peer, pkKey, {
+      ...options,
+      path
+    })) {
       yield event
 
       if (event.name === 'PEER_RESPONSE' && event.record != null) {
@@ -143,7 +151,8 @@ export class PeerRouting {
 
         yield valueEvent({
           from: peer,
-          value: event.record.value
+          value: event.record.value,
+          path
         }, options)
       }
     }
@@ -165,8 +174,14 @@ export class PeerRouting {
       if (pi != null) {
         this.log('found local')
         yield finalPeerEvent({
-          from: this.peerId,
-          peer: pi
+          from: this.components.peerId,
+          peer: pi,
+          path: {
+            index: -1,
+            queued: 0,
+            running: 0,
+            total: 0
+          }
         }, options)
         return
       }
@@ -177,15 +192,16 @@ export class PeerRouting {
     if (options.useNetwork !== false) {
       const self = this // eslint-disable-line @typescript-eslint/no-this-alias
 
-      const findPeerQuery: QueryFunc = async function * ({ peer, signal }) {
+      const findPeerQuery: QueryFunc = async function * ({ peer, signal, path }) {
         const request: Partial<Message> = {
           type: MessageType.FIND_NODE,
           key: id.toMultihash().bytes
         }
 
-        for await (const event of self.network.sendRequest(peer, request, {
+        for await (const event of self.network.sendRequest(peer.id, request, {
           ...options,
-          signal
+          signal,
+          path
         })) {
           yield event
 
@@ -194,7 +210,11 @@ export class PeerRouting {
 
             // found the peer
             if (match != null) {
-              yield finalPeerEvent({ from: event.from, peer: match }, options)
+              yield finalPeerEvent({
+                from: event.from,
+                peer: match,
+                path: event.path
+              }, options)
             }
           }
         }
@@ -210,53 +230,64 @@ export class PeerRouting {
     }
 
     if (!foundPeer) {
-      yield queryErrorEvent({ from: this.peerId, error: new NotFoundError('Not found') }, options)
+      throw new NotFoundError('Not found')
     }
   }
 
   /**
-   * Kademlia 'FIND_NODE' operation on a key, which could be the bytes from
-   * a multihash or a peer ID
+   * Kademlia 'FIND_NODE' operation on a key, which could be the bytes from a
+   * multihash or a peer ID
    */
   async * getClosestPeers (key: Uint8Array, options: QueryOptions = {}): AsyncGenerator<QueryEvent> {
     this.log('getClosestPeers to %b', key)
     const kadId = await convertBuffer(key)
-    const tablePeers = this.routingTable.closestPeers(kadId)
-    const self = this // eslint-disable-line @typescript-eslint/no-this-alias
-
     const peers = new PeerDistanceList(kadId, this.routingTable.kBucketSize)
-    await Promise.all(tablePeers.map(async peer => { await peers.add({ id: peer, multiaddrs: [] }) }))
+    const self = this // eslint-disable-line @typescript-eslint/no-this-alias
 
-    const getCloserPeersQuery: QueryFunc = async function * ({ peer, signal }) {
-      self.log('closerPeersSingle %s from %p', uint8ArrayToString(key, 'base32'), peer)
+    const getCloserPeersQuery: QueryFunc = async function * ({ peer, path, peerKadId, signal }) {
+      self.log('getClosestPeers asking %p', peer)
       const request: Partial<Message> = {
         type: MessageType.FIND_NODE,
         key
       }
 
-      yield * self.network.sendRequest(peer, request, {
+      yield * self.network.sendRequest(peer.id, request, {
         ...options,
-        signal
+        signal,
+        path
       })
-    }
 
-    for await (const event of this.queryManager.run(key, getCloserPeersQuery, options)) {
-      if (event.name === 'PEER_RESPONSE') {
-        await Promise.all(event.closer.map(async peerData => {
-          await peers.add(peerData)
-        }))
-      }
-
-      yield event
+      // add the peer to the list if we've managed to contact it successfully
+      peers.addWithKadId(peer, peerKadId, path)
     }
 
+    yield * this.queryManager.run(key, getCloserPeersQuery, options)
+
     this.log('found %d peers close to %b', peers.length, key)
 
-    for (const peer of peers.peers) {
-      yield finalPeerEvent({
-        from: this.peerId,
-        peer
-      }, options)
+    for (let { peer, path } of peers.peers) {
+      try {
+        if (peer.multiaddrs.length === 0) {
+          peer = await self.components.peerStore.getInfo(peer.id)
+        }
+
+        if (peer.multiaddrs.length === 0) {
+          continue
+        }
+
+        yield finalPeerEvent({
+          from: this.components.peerId,
+          peer: await self.components.peerStore.getInfo(peer.id),
+          path: {
+            index: path.index,
+            queued: 0,
+            running: 0,
+            total: 0
+          }
+        }, options)
+      } catch {
+        continue
+      }
     }
   }
 
@@ -266,7 +297,7 @@ export class PeerRouting {
    *
    * Note: The peerStore is updated with new addresses found for the given peer.
    */
-  async * getValueOrPeers (peer: PeerId, key: Uint8Array, options: RoutingOptions = {}): AsyncGenerator<QueryEvent> {
+  async * getValueOrPeers (peer: PeerId, key: Uint8Array, options: SendMessageOptions): AsyncGenerator<QueryEvent> {
     for await (const event of this._getValueSingle(peer, key, options)) {
       if (event.name === 'PEER_RESPONSE') {
         if (event.record != null) {
@@ -277,7 +308,11 @@ export class PeerRouting {
             const errMsg = 'invalid record received, discarded'
             this.log(errMsg)
 
-            yield queryErrorEvent({ from: event.from, error: new QueryError(errMsg) }, options)
+            yield queryErrorEvent({
+              from: event.from,
+              error: new QueryError(errMsg),
+              path: options.path
+            }, options)
             continue
           }
         }
@@ -300,7 +335,8 @@ export class PeerRouting {
   }
 
   /**
-   * Get the nearest peers to the given query, but if closer than self
+   * Get the peers in our routing table that are closer than the passed PeerId
+   * to the passed key
    */
   async getCloserPeersOffline (key: Uint8Array, closerThan: PeerId): Promise<PeerInfo[]> {
     const output: PeerInfo[] = []
@@ -310,7 +346,7 @@ export class PeerRouting {
       const multihash = Digest.decode(key)
       const targetPeerId = peerIdFromMultihash(multihash)
 
-      const peer = await this.peerStore.get(targetPeerId)
+      const peer = await this.components.peerStore.get(targetPeerId)
 
       output.push({
         id: peer.id,
@@ -333,12 +369,7 @@ export class PeerRouting {
       }
 
       try {
-        const peer = await this.peerStore.get(peerId)
-
-        output.push({
-          id: peerId,
-          multiaddrs: peer.addresses.map(({ multiaddr }) => multiaddr)
-        })
+        output.push(await this.components.peerStore.getInfo(peerId))
       } catch (err: any) {
         if (err.name !== 'NotFoundError') {
           throw err

package/src/providers.ts

@@ -1,7 +1,7 @@
 import { PeerMap } from '@libp2p/peer-collections'
 import * as varint from 'uint8-varint'
 import { parseProviderKey, readProviderTime, toProviderKey } from './utils.js'
-import type { ComponentLogger, Logger, Metrics, PeerId } from '@libp2p/interface'
+import type { AbortOptions, ComponentLogger, Logger, Metrics, PeerId } from '@libp2p/interface'
 import type { Datastore } from 'interface-datastore'
 import type { Mortice } from 'mortice'
 import type { CID } from 'multiformats'
@@ -37,11 +37,11 @@ export class Providers {
   /**
    * Add a new provider for the given CID
    */
-  async addProvider (cid: CID, provider: PeerId): Promise<void> {
+  async addProvider (cid: CID, provider: PeerId, options?: AbortOptions): Promise<void> {
     const release = await this.lock.readLock()
 
     try {
-      this.log('%p provides %s', provider, cid)
+      this.log.trace('%p provides %s', provider, cid)
       await this.writeProviderEntry(cid, provider)
     } finally {
       release()
@@ -51,12 +51,12 @@ export class Providers {
   /**
    * Remove a provider for the given CID
    */
-  async removeProvider (cid: CID, provider: PeerId): Promise<void> {
+  async removeProvider (cid: CID, provider: PeerId, options?: AbortOptions): Promise<void> {
     const release = await this.lock.writeLock()
 
     try {
       const key = toProviderKey(this.datastorePrefix, cid, provider)
-      this.log('%p no longer provides %s', provider, cid)
+      this.log.trace('%p no longer provides %s', provider, cid)
       await this.datastore.delete(key)
     } finally {
       release()
@@ -66,13 +66,13 @@ export class Providers {
   /**
    * Get a list of providers for the given CID
    */
-  async getProviders (cid: CID): Promise<PeerId[]> {
+  async getProviders (cid: CID, options?: AbortOptions): Promise<PeerId[]> {
     const release = await this.lock.readLock()
 
     try {
-      this.log('get providers for %c', cid)
-      const provs = await this.loadProviders(cid)
-      this.log('got %d providers for %c', provs.size, cid)
+      this.log.trace('get providers for %c', cid)
+      const provs = await this.loadProviders(cid, options)
+      this.log.trace('got %d providers for %c', provs.size, cid)
 
       return [...provs.keys()]
     } finally {
@@ -83,21 +83,21 @@ export class Providers {
   /**
    * Write a provider into the given store
    */
-  private async writeProviderEntry (cid: CID, peerId: PeerId, time: Date = new Date()): Promise<void> {
+  private async writeProviderEntry (cid: CID, peerId: PeerId, time: Date = new Date(), options?: AbortOptions): Promise<void> {
     const key = toProviderKey(this.datastorePrefix, cid, peerId)
     const buffer = varint.encode(time.getTime())
 
-    await this.datastore.put(key, buffer)
+    await this.datastore.put(key, buffer, options)
   }
 
   /**
    * Load providers for the given CID from the store
    */
-  private async loadProviders (cid: CID): Promise<PeerMap<Date>> {
+  private async loadProviders (cid: CID, options?: AbortOptions): Promise<PeerMap<Date>> {
     const providers = new PeerMap<Date>()
     const key = toProviderKey(this.datastorePrefix, cid)
 
-    for await (const entry of this.datastore.query({ prefix: key.toString() })) {
+    for await (const entry of this.datastore.query({ prefix: key.toString() }, options)) {
       const { peerId } = parseProviderKey(entry.key)
       providers.set(peerId, readProviderTime(entry.value))
     }

package/src/query/events.ts

@@ -1,4 +1,4 @@
-import type { MessageType, SendQueryEvent, PeerResponseEvent, DialPeerEvent, AddPeerEvent, ValueEvent, ProviderEvent, QueryErrorEvent, FinalPeerEvent } from '../index.js'
+import type { MessageType, SendQueryEvent, PeerResponseEvent, AddPeerEvent, ValueEvent, ProviderEvent, QueryErrorEvent, FinalPeerEvent, DisjointPath, PathEndedEvent, DialPeerEvent } from '../index.js'
 import type { PeerId, PeerInfo } from '@libp2p/interface'
 import type { Libp2pRecord } from '@libp2p/record'
 import type { ProgressOptions } from 'progress-events'
@@ -6,6 +6,7 @@ import type { ProgressOptions } from 'progress-events'
 export interface QueryEventFields {
   to: PeerId
   type: MessageType
+  path: DisjointPath
 }
 
 export function sendQueryEvent (fields: QueryEventFields, options: ProgressOptions = {}): SendQueryEvent {
@@ -25,6 +26,7 @@ export function sendQueryEvent (fields: QueryEventFields, options: ProgressOptio
 export interface PeerResponseEventFields {
   from: PeerId
   messageType: MessageType
+  path: DisjointPath
   closer?: PeerInfo[]
   providers?: PeerInfo[]
   record?: Libp2pRecord
@@ -48,6 +50,7 @@ export function peerResponseEvent (fields: PeerResponseEventFields, options: Pro
 export interface FinalPeerEventFields {
   from: PeerId
   peer: PeerInfo
+  path: DisjointPath
 }
 
 export function finalPeerEvent (fields: FinalPeerEventFields, options: ProgressOptions = {}): FinalPeerEvent {
@@ -65,6 +68,7 @@ export function finalPeerEvent (fields: FinalPeerEventFields, options: ProgressO
 export interface ErrorEventFields {
   from: PeerId
   error: Error
+  path: DisjointPath
 }
 
 export function queryErrorEvent (fields: ErrorEventFields, options: ProgressOptions = {}): QueryErrorEvent {
@@ -82,6 +86,7 @@ export function queryErrorEvent (fields: ErrorEventFields, options: ProgressOpti
 export interface ProviderEventFields {
   from: PeerId
   providers: PeerInfo[]
+  path: DisjointPath
 }
 
 export function providerEvent (fields: ProviderEventFields, options: ProgressOptions = {}): ProviderEvent {
@@ -99,6 +104,7 @@ export function providerEvent (fields: ProviderEventFields, options: ProgressOpt
 export interface ValueEventFields {
   from: PeerId
   value: Uint8Array
+  path: DisjointPath
 }
 
 export function valueEvent (fields: ValueEventFields, options: ProgressOptions = {}): ValueEvent {
@@ -113,11 +119,12 @@ export function valueEvent (fields: ValueEventFields, options: ProgressOptions =
   return event
 }
 
-export interface PeerEventFields {
+export interface AddPeerEventFields {
   peer: PeerId
+  path: DisjointPath
 }
 
-export function addPeerEvent (fields: PeerEventFields, options: ProgressOptions = {}): AddPeerEvent {
+export function addPeerEvent (fields: AddPeerEventFields, options: ProgressOptions = {}): AddPeerEvent {
   const event: AddPeerEvent = {
     ...fields,
     name: 'ADD_PEER',
@@ -131,6 +138,7 @@ export function addPeerEvent (fields: PeerEventFields, options: ProgressOptions
 
 export interface DialPeerEventFields {
   peer: PeerId
+  path: DisjointPath
 }
 
 export function dialPeerEvent (fields: DialPeerEventFields, options: ProgressOptions = {}): DialPeerEvent {
@@ -144,3 +152,19 @@ export function dialPeerEvent (fields: DialPeerEventFields, options: ProgressOpt
 
   return event
 }
+
+export interface PathEndedEventFields {
+  path: DisjointPath
+}
+
+export function pathEndedEvent (fields: PathEndedEventFields, options: ProgressOptions = {}): PathEndedEvent {
+  const event: PathEndedEvent = {
+    ...fields,
+    name: 'PATH_ENDED',
+    type: 8
+  }
+
+  options.onProgress?.(new CustomEvent('kad-dht:query:path-ended', { detail: event }))
+
+  return event
+}

package/src/query/manager.ts

@@ -1,7 +1,9 @@
+/* eslint-disable complexity */
 import { setMaxListeners } from '@libp2p/interface'
-import { PeerSet } from '@libp2p/peer-collections'
+import { createScalableCuckooFilter } from '@libp2p/utils/filters'
 import { anySignal } from 'any-signal'
 import merge from 'it-merge'
+import { pEvent } from 'p-event'
 import { raceSignal } from 'race-signal'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import {
@@ -26,6 +28,7 @@ export interface QueryManagerInit {
   disjointPaths?: number
   alpha?: number
   initialQuerySelfHasRun: DeferredPromise<void>
+  allowQueryWithZeroPeers?: boolean
   routingTable: RoutingTable
 }
 
@@ -37,11 +40,6 @@ export interface QueryManagerComponents {
 }
 
 export interface QueryOptions extends RoutingOptions {
-  /**
-   * A timeout for subqueries executed as part of the main query
-   */
-  queryFuncTimeout?: number
-
   isSelfQuery?: boolean
 }
 
@@ -59,6 +57,7 @@ export class QueryManager implements Startable {
   private readonly routingTable: RoutingTable
   private initialQuerySelfHasRun?: DeferredPromise<void>
   private readonly logPrefix: string
+  private readonly allowQueryWithZeroPeers: boolean
 
   constructor (components: QueryManagerComponents, init: QueryManagerInit) {
     this.logPrefix = init.logPrefix
@@ -69,6 +68,7 @@ export class QueryManager implements Startable {
     this.logger = components.logger
     this.peerId = components.peerId
     this.connectionManager = components.connectionManager
+    this.allowQueryWithZeroPeers = init.allowQueryWithZeroPeers ?? false
 
     // allow us to stop queries on shut down
     this.shutDownController = new AbortController()
@@ -146,8 +146,18 @@ export class QueryManager implements Startable {
     let queryFinished = false
 
     try {
+      if (this.routingTable.size === 0 && !this.allowQueryWithZeroPeers) {
+        log('routing table was empty, waiting for some peers before running%s query', options.isSelfQuery === true ? ' self' : '')
+        // wait to discover at least one DHT peer that isn't us
+        await pEvent(this.routingTable, 'peer:add', {
+          signal,
+          filter: (event) => !this.peerId.equals(event.detail)
+        })
+        log('routing table has peers, continuing with%s query', options.isSelfQuery === true ? ' self' : '')
+      }
+
       if (options.isSelfQuery !== true && this.initialQuerySelfHasRun != null) {
-        log('waiting for initial query-self query before continuing')
+        log('waiting for initial self query before continuing')
 
         await raceSignal(this.initialQuerySelfHasRun.promise, signal)
 
@@ -157,30 +167,43 @@ export class QueryManager implements Startable {
       log('query:start')
 
       const id = await convertBuffer(key)
-      const peers = this.routingTable.closestPeers(id)
-      const peersToQuery = peers.slice(0, Math.min(this.disjointPaths, peers.length))
+      const peers = this.routingTable.closestPeers(id, this.routingTable.kBucketSize)
+
+      // split peers into d buckets evenly(ish)
+      const peersToQuery = peers.sort(() => {
+        if (Math.random() > 0.5) {
+          return 1
+        }
+
+        return -1
+      })
+        .reduce((acc: PeerId[][], curr, index) => {
+          acc[index % this.disjointPaths].push(curr)
+
+          return acc
+        }, new Array(this.disjointPaths).fill(0).map(() => []))
+        .filter(peers => peers.length > 0)
 
       if (peers.length === 0) {
-        log.error('Running query with no peers')
+        log.error('running query with no peers')
         return
       }
 
       // make sure we don't get trapped in a loop
-      const peersSeen = new PeerSet()
+      const peersSeen = createScalableCuckooFilter(1024)
 
       // Create query paths from the starting peers
       const paths = peersToQuery.map((peer, index) => {
         return queryPath({
           ...options,
           key,
-          startingPeer: peer,
+          startingPeers: peer,
           ourPeerId: this.peerId,
           signal,
           query: queryFunc,
-          pathIndex: index,
+          path: index,
           numPaths: peersToQuery.length,
           alpha: this.alpha,
-          queryFuncTimeout: options.queryFuncTimeout,
           log,
           peersSeen,
           onProgress: options.onProgress,
@@ -197,22 +220,26 @@ export class QueryManager implements Startable {
         if (event.name === 'PEER_RESPONSE') {
           for (const peer of [...event.closer, ...event.providers]) {
             // eslint-disable-next-line max-depth
-            if (!(await this.connectionManager.isDialable(peer.multiaddrs))) {
+            if (!(await this.connectionManager.isDialable(peer.multiaddrs, {
+              signal
+            }))) {
               continue
             }
 
-            await this.routingTable.add(peer.id)
+            await this.routingTable.add(peer.id, {
+              signal
+            })
           }
         }
 
+        signal.throwIfAborted()
         yield event
       }
 
       queryFinished = true
-    } catch (err: any) {
-      if (!this.running && err.name === 'QueryAbortedError') {
-        // ignore query aborted errors that were thrown during query manager shutdown
-      } else {
+    } catch (err) {
+      if (this.running) {
+        // ignore errors thrown during shut down
         throw err
       }
     } finally {
@@ -223,7 +250,7 @@ export class QueryManager implements Startable {
 
       signal.clear()
 
-      log('query:done')
+      log('query finished')
     }
   }
 }