@helia/bitswap 0.0.0-b67ac5f → 0.0.0-ba4b7ba

package/src/want-list.ts

@@ -1,4 +1,4 @@
-import { TypedEventEmitter, setMaxListeners } from '@libp2p/interface'
+import { AbortError } from '@libp2p/interface'
 import { trackedPeerMap, PeerSet } from '@libp2p/peer-collections'
 import { trackedMap } from '@libp2p/utils/tracked-map'
 import all from 'it-all'
@@ -8,16 +8,14 @@ import { pipe } from 'it-pipe'
 import { CID } from 'multiformats/cid'
 import { sha256 } from 'multiformats/hashes/sha2'
 import pDefer from 'p-defer'
-import { raceEvent } from 'race-event'
-import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { DEFAULT_MESSAGE_SEND_DELAY } from './constants.js'
 import { BlockPresenceType, WantType } from './pb/message.js'
 import vd from './utils/varint-decoder.js'
-import type { BitswapNotifyProgressEvents, MultihashHasherLoader } from './index.js'
+import type { MultihashHasherLoader } from './index.js'
 import type { BitswapNetworkWantProgressEvents, Network } from './network.js'
 import type { BitswapMessage } from './pb/message.js'
-import type { ComponentLogger, PeerId, Startable, AbortOptions, Libp2p, TypedEventTarget } from '@libp2p/interface'
+import type { ComponentLogger, Metrics, PeerId, Startable, AbortOptions } from '@libp2p/interface'
 import type { Logger } from '@libp2p/logger'
 import type { PeerMap } from '@libp2p/peer-collections'
 import type { DeferredPromise } from 'p-defer'
@@ -26,7 +24,7 @@ import type { ProgressOptions } from 'progress-events'
 export interface WantListComponents {
   network: Network
   logger: ComponentLogger
-  libp2p: Libp2p
+  metrics?: Metrics
 }
 
 export interface WantListInit {
@@ -65,6 +63,16 @@ export interface WantListEntry {
    * If this set has members, the want will only be sent to these peers
    */
   session: PeerSet
+
+  /**
+   * Promises returned from `.wantBlock` for this block
+   */
+  blockWantListeners: Array<DeferredPromise<WantBlockResult>>
+
+  /**
+   * Promises returned from `.wantPresence` for this block
+   */
+  blockPresenceListeners: Array<DeferredPromise<WantPresenceResult>>
 }
 
 export interface WantOptions extends AbortOptions, ProgressOptions<BitswapNetworkWantProgressEvents> {
@@ -100,12 +108,7 @@ export interface WantHaveResult {
 
 export type WantPresenceResult = WantDontHaveResult | WantHaveResult
 
-export interface WantListEvents {
-  block: CustomEvent<WantBlockResult>
-  presence: CustomEvent<WantPresenceResult>
-}
-
-export class WantList extends TypedEventEmitter<WantListEvents> implements Startable, TypedEventTarget<WantListEvents> {
+export class WantList implements Startable {
   /**
    * Tracks what CIDs we've previously sent to which peers
    */
@@ -116,19 +119,15 @@ export class WantList extends TypedEventEmitter<WantListEvents> implements Start
   private readonly sendMessagesDelay: number
   private sendMessagesTimeout?: ReturnType<typeof setTimeout>
   private readonly hashLoader?: MultihashHasherLoader
-  private sendingMessages?: DeferredPromise<void>
 
   constructor (components: WantListComponents, init: WantListInit = {}) {
-    super()
-
-    setMaxListeners(Infinity, this)
     this.peers = trackedPeerMap({
       name: 'ipfs_bitswap_peers',
-      metrics: components.libp2p.metrics
+      metrics: components.metrics
     })
     this.wants = trackedMap({
       name: 'ipfs_bitswap_wantlist',
-      metrics: components.libp2p.metrics
+      metrics: components.metrics
     })
     this.network = components.network
     this.sendMessagesDelay = init.sendMessagesDelay ?? DEFAULT_MESSAGE_SEND_DELAY
@@ -165,7 +164,9 @@ export class WantList extends TypedEventEmitter<WantListEvents> implements Start
         priority: options.priority ?? 1,
         wantType: options.wantType ?? WantType.WantBlock,
         cancel: false,
-        sendDontHave: true
+        sendDontHave: true,
+        blockWantListeners: [],
+        blockPresenceListeners: []
       }
 
       if (options.peerId != null) {
@@ -197,41 +198,30 @@ export class WantList extends TypedEventEmitter<WantListEvents> implements Start
       }
     }
 
-    // broadcast changes
-    await this.sendMessagesDebounced()
+    // add a promise that will be resolved or rejected when the response arrives
+    let deferred: DeferredPromise<WantBlockResult | WantPresenceResult>
 
-    try {
-      if (options.wantType === WantType.WantBlock) {
-        const event = await raceEvent<CustomEvent<WantBlockResult>>(this, 'block', options?.signal, {
-          filter: (event) => {
-            return uint8ArrayEquals(cid.multihash.digest, event.detail.cid.multihash.digest)
-          },
-          errorMessage: 'Want was aborted'
-        })
+    if (options.wantType === WantType.WantBlock) {
+      const p = deferred = pDefer<WantBlockResult>()
 
-        return event.detail
-      }
+      entry.blockWantListeners.push(p)
+    } else {
+      const p = deferred = pDefer<WantPresenceResult>()
 
-      const event = await raceEvent<CustomEvent<WantPresenceResult>>(this, 'presence', options?.signal, {
-        filter: (event) => {
-          return uint8ArrayEquals(cid.multihash.digest, event.detail.cid.multihash.digest)
-        },
-        errorMessage: 'Want was aborted'
-      })
+      entry.blockPresenceListeners.push(p)
+    }
 
-      return event.detail
-    } finally {
-      if (options.signal?.aborted === true) {
-        this.log('want for %c was aborted, cancelling want', cid)
+    // reject the promise if the want is rejected
+    const abortListener = (): void => {
+      this.log('want for %c was aborted, cancelling want', cid)
+
+      if (entry != null) {
         entry.cancel = true
-        // broadcast changes
-        await this.sendMessagesDebounced()
       }
-    }
-  }
 
-  private async sendMessagesDebounced (): Promise<void> {
-    await this.sendingMessages?.promise
+      deferred.reject(new AbortError('Want was aborted'))
+    }
+    options.signal?.addEventListener('abort', abortListener)
 
     // broadcast changes
     clearTimeout(this.sendMessagesTimeout)
@@ -241,70 +231,77 @@ export class WantList extends TypedEventEmitter<WantListEvents> implements Start
           this.log('error sending messages to peers', err)
         })
     }, this.sendMessagesDelay)
+
+    try {
+      return await deferred.promise
+    } finally {
+      // remove listener
+      options.signal?.removeEventListener('abort', abortListener)
+      // remove deferred promise
+      if (options.wantType === WantType.WantBlock) {
+        entry.blockWantListeners = entry.blockWantListeners.filter(recipient => recipient !== deferred)
+      } else {
+        entry.blockPresenceListeners = entry.blockPresenceListeners.filter(recipient => recipient !== deferred)
+      }
+    }
   }
 
   private async sendMessages (): Promise<void> {
-    this.sendingMessages = pDefer()
-
-    await Promise.all(
-      [...this.peers.entries()].map(async ([peerId, sentWants]) => {
-        const sent = new Set<string>()
-        const message: Partial<BitswapMessage> = {
-          wantlist: {
-            full: false,
-            entries: pipe(
-              this.wants.entries(),
-              (source) => filter(source, ([key, entry]) => {
-                // skip session-only wants
-                if (entry.session.size > 0 && !entry.session.has(peerId)) {
-                  return false
-                }
-
-                const sentPreviously = sentWants.has(key)
-
-                // don't cancel if we've not sent it to them before
-                if (entry.cancel) {
-                  return sentPreviously
-                }
-
-                // only send if we've not sent it to them before
-                return !sentPreviously
-              }),
-              (source) => map(source, ([key, entry]) => {
-                sent.add(key)
-
-                return {
-                  cid: entry.cid.bytes,
-                  priority: entry.priority,
-                  wantType: entry.wantType,
-                  cancel: entry.cancel,
-                  sendDontHave: entry.sendDontHave
-                }
-              }),
-              (source) => all(source)
-            )
-          }
+    for (const [peerId, sentWants] of this.peers) {
+      const sent = new Set<string>()
+      const message: Partial<BitswapMessage> = {
+        wantlist: {
+          full: false,
+          entries: pipe(
+            this.wants.entries(),
+            (source) => filter(source, ([key, entry]) => {
+              // skip session-only wants
+              if (entry.session.size > 0 && !entry.session.has(peerId)) {
+                return false
+              }
+
+              const sentPreviously = sentWants.has(key)
+
+              // don't cancel if we've not sent it to them before
+              if (entry.cancel) {
+                return sentPreviously
+              }
+
+              // only send if we've not sent it to them before
+              return !sentPreviously
+            }),
+            (source) => map(source, ([key, entry]) => {
+              sent.add(key)
+
+              return {
+                cid: entry.cid.bytes,
+                priority: entry.priority,
+                wantType: entry.wantType,
+                cancel: entry.cancel,
+                sendDontHave: entry.sendDontHave
+              }
+            }),
+            (source) => all(source)
+          )
         }
+      }
 
-        if (message.wantlist?.entries.length === 0) {
-          return
-        }
+      if (message.wantlist?.entries.length === 0) {
+        return
+      }
 
-        // add message to send queue
-        try {
-          await this.network.sendMessage(peerId, message)
+      // add message to send queue
+      try {
+        await this.network.sendMessage(peerId, message)
 
-          // update list of messages sent to remote
-          for (const key of sent) {
-            sentWants.add(key)
-          }
-        } catch (err: any) {
-          this.log.error('error sending full wantlist to new peer', err)
+        // update list of messages sent to remote
+        for (const key of sent) {
+          sentWants.add(key)
         }
-      })
-    ).catch(err => {
-      this.log.error('error sending messages', err)
-    })
+      } catch (err: any) {
+        this.log.error('error sending full wantlist to new peer', err)
+      }
+    }
 
     // queued all message sends, remove cancelled wants from wantlist and sent
     // wants
@@ -317,8 +314,6 @@ export class WantList extends TypedEventEmitter<WantListEvents> implements Start
         }
       }
     }
-
-    this.sendingMessages.resolve()
   }
 
   has (cid: CID): boolean {
@@ -330,30 +325,31 @@ export class WantList extends TypedEventEmitter<WantListEvents> implements Start
    * Add a CID to the wantlist
    */
   async wantPresence (cid: CID, options: WantOptions = {}): Promise<WantPresenceResult> {
-    if (options.peerId != null) {
-      const peer = options.peerId
+    if (options.peerId != null && this.peers.get(options.peerId) == null) {
+      const cidStr = uint8ArrayToString(cid.multihash.bytes, 'base64')
 
-      // sending WantHave directly to peer
-      await this.network.sendMessage(options.peerId, {
-        wantlist: {
-          full: false,
-          entries: [{
-            cid: cid.bytes,
-            sendDontHave: true,
-            wantType: WantType.WantHave,
-            priority: 1
-          }]
-        }
-      })
+      try {
+        // if we don't have them as a peer, add them
+        this.peers.set(options.peerId, new Set([cidStr]))
 
-      // wait for peer response
-      const event = await raceEvent<CustomEvent<WantHaveResult | WantDontHaveResult>>(this, 'presence', options.signal, {
-        filter: (event) => {
-          return peer.equals(event.detail.sender) && uint8ArrayEquals(cid.multihash.digest, event.detail.cid.multihash.digest)
-        }
-      })
+        // sending WantHave directly to peer
+        await this.network.sendMessage(options.peerId, {
+          wantlist: {
+            full: false,
+            entries: [{
+              cid: cid.bytes,
+              sendDontHave: true,
+              wantType: WantType.WantHave,
+              priority: 1
+            }]
+          }
+        })
+      } catch (err) {
+        // sending failed, remove them as a peer
+        this.peers.delete(options.peerId)
 
-      return event.detail
+        throw err
+      }
     }
 
     return this.addEntry(cid, {
@@ -372,29 +368,15 @@ export class WantList extends TypedEventEmitter<WantListEvents> implements Start
     })
   }
 
-  /**
-   * Invoked when a block has been received from an external source
-   */
-  async receivedBlock (cid: CID, options: ProgressOptions<BitswapNotifyProgressEvents> & AbortOptions): Promise<void> {
-    const cidStr = uint8ArrayToString(cid.multihash.bytes, 'base64')
-
-    const entry = this.wants.get(cidStr)
-
-    if (entry == null) {
-      return
-    }
-
-    entry.cancel = true
-
-    await this.sendMessagesDebounced()
-  }
-
   /**
    * Invoked when a message is received from a bitswap peer
    */
   private async receiveMessage (sender: PeerId, message: BitswapMessage): Promise<void> {
     this.log('received message from %p', sender)
-    let blocksCancelled = false
+
+    // blocks received
+    const blockResults: WantBlockResult[] = []
+    const presenceResults: WantPresenceResult[] = []
 
     // process blocks
     for (const block of message.blocks) {
@@ -402,6 +384,7 @@ export class WantList extends TypedEventEmitter<WantListEvents> implements Start
         continue
       }
 
+      this.log('received block')
       const values = vd(block.prefix)
       const cidVersion = values[0]
       const multicodec = values[1]
@@ -420,55 +403,66 @@ export class WantList extends TypedEventEmitter<WantListEvents> implements Start
 
       this.log('received block from %p for %c', sender, cid)
 
-      this.safeDispatchEvent<WantBlockResult>('block', {
-        detail: {
-          sender,
-          cid,
-          block: block.data
-        }
+      blockResults.push({
+        sender,
+        cid,
+        block: block.data
       })
 
-      this.safeDispatchEvent<WantHaveResult | WantDontHaveResult>('presence', {
-        detail: {
-          sender,
-          cid,
-          has: true,
-          block: block.data
-        }
+      presenceResults.push({
+        sender,
+        cid,
+        has: true
       })
+    }
 
-      const cidStr = uint8ArrayToString(cid.multihash.bytes, 'base64')
+    // process block presences
+    for (const { cid: cidBytes, type } of message.blockPresences) {
+      const cid = CID.decode(cidBytes)
+
+      this.log('received %s from %p for %c', type, sender, cid)
+
+      presenceResults.push({
+        sender,
+        cid,
+        has: type === BlockPresenceType.HaveBlock
+      })
+    }
+
+    for (const result of blockResults) {
+      const cidStr = uint8ArrayToString(result.cid.multihash.bytes, 'base64')
       const entry = this.wants.get(cidStr)
 
       if (entry == null) {
         return
       }
 
+      const recipients = entry.blockWantListeners
+      entry.blockWantListeners = []
+      recipients.forEach((p) => {
+        p.resolve(result)
+      })
+
       // since we received the block, flip the cancel flag to send cancels to
       // any peers on the next message sending iteration, this will remove it
       // from the internal want list
       entry.cancel = true
-      blocksCancelled = true
     }
 
-    // process block presences
-    for (const { cid: cidBytes, type } of message.blockPresences) {
-      const cid = CID.decode(cidBytes)
+    for (const result of presenceResults) {
+      const cidStr = uint8ArrayToString(result.cid.multihash.bytes, 'base64')
+      const entry = this.wants.get(cidStr)
 
-      this.log('received %s from %p for %c', type, sender, cid)
+      if (entry == null) {
+        return
+      }
 
-      this.safeDispatchEvent<WantHaveResult | WantDontHaveResult>('presence', {
-        detail: {
-          sender,
-          cid,
-          has: type === BlockPresenceType.HaveBlock
-        }
+      const recipients = entry.blockPresenceListeners
+      entry.blockPresenceListeners = []
+      recipients.forEach((p) => {
+        p.resolve(result)
       })
     }
-
-    if (blocksCancelled) {
-      await this.sendMessagesDebounced()
-    }
   }
 
   /**