@libp2p/floodsub 11.0.1 → 11.0.2-334f91bdc

package/src/peer-streams.ts

@@ -1,22 +1,15 @@
-import { AbortError } from '@libp2p/interface'
-import { pipe } from '@libp2p/utils'
-import * as lp from 'it-length-prefixed'
-import { pushable } from 'it-pushable'
+import { pbStream } from '@libp2p/utils'
 import { TypedEventEmitter } from 'main-event'
-import { pEvent } from 'p-event'
-import { Uint8ArrayList } from 'uint8arraylist'
-import type { PeerStreamEvents } from './index.ts'
-import type { ComponentLogger, Logger, Stream, PeerId } from '@libp2p/interface'
+import { RPC } from './message/rpc.ts'
+import type { PubSubRPC } from './floodsub.ts'
+import type { PeerStreamsEvents } from './index.ts'
+import type { Stream, PeerId } from '@libp2p/interface'
+import type { ProtobufMessageStream, ProtobufStreamOpts } from '@libp2p/utils'
 import type { DecoderOptions as LpDecoderOptions } from 'it-length-prefixed'
-import type { Pushable } from 'it-pushable'
 
-export interface PeerStreamsInit {
-  id: PeerId
-  protocol: string
-}
-
-export interface PeerStreamsComponents {
-  logger: ComponentLogger
+export interface PeerStreamInit {
+  peerId: PeerId
+  stream: Stream
 }
 
 export interface DecoderOptions extends LpDecoderOptions {
@@ -26,175 +19,86 @@ export interface DecoderOptions extends LpDecoderOptions {
 /**
  * Thin wrapper around a peer's inbound / outbound pubsub streams
  */
-export class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
-  public readonly id: PeerId
-  public readonly protocol: string
-  /**
-   * Write stream - it's preferable to use the write method
-   */
-  public outboundStream?: Pushable<Uint8ArrayList>
-  /**
-   * Read stream
-   */
-  public inboundStream?: AsyncIterable<Uint8ArrayList>
-  /**
-   * The raw outbound stream, as retrieved from conn.newStream
-   */
-  private _rawOutboundStream?: Stream
-  /**
-   * The raw inbound stream, as retrieved from the callback from libp2p.handle
-   */
-  private _rawInboundStream?: Stream
+export class PeerStreams extends TypedEventEmitter<PeerStreamsEvents> {
+  public readonly peerId: PeerId
+
   /**
    * An AbortController for controlled shutdown of the inbound stream
    */
-  private readonly _inboundAbortController: AbortController
-  private closed: boolean
-  private readonly log: Logger
+  private readonly shutDownController: AbortController
+  // messages sent by the remote
+  private inboundPb?: ProtobufMessageStream<RPC>
+  // messages we send
+  private outboundPb?: ProtobufMessageStream<RPC>
 
-  constructor (components: PeerStreamsComponents, init: PeerStreamsInit) {
+  constructor (peerId: PeerId) {
     super()
 
-    this.log = components.logger.forComponent('libp2p-pubsub:peer-streams')
-    this.id = init.id
-    this.protocol = init.protocol
-
-    this._inboundAbortController = new AbortController()
-    this.closed = false
+    this.peerId = peerId
+    this.shutDownController = new AbortController()
   }
 
-  /**
-   * Do we have a connection to read from?
-   */
-  get isReadable (): boolean {
-    return Boolean(this.inboundStream)
-  }
-
-  /**
-   * Do we have a connection to write on?
-   */
-  get isWritable (): boolean {
-    return Boolean(this.outboundStream)
-  }
+  attachInboundStream (stream: Stream, streamOpts?: Partial<ProtobufStreamOpts>): void {
+    this.inboundPb = pbStream(stream, streamOpts).pb(RPC)
 
-  /**
-   * Send a message to this peer.
-   * Throws if there is no `stream` to write to available.
-   */
-  write (data: Uint8Array | Uint8ArrayList): void {
-    if (this.outboundStream == null) {
-      const id = this.id.toString()
-      throw new Error('No writable connection to ' + id)
-    }
-
-    this.outboundStream.push(data instanceof Uint8Array ? new Uint8ArrayList(data) : data)
-  }
+    Promise.resolve().then(async () => {
+      while (true) {
+        if (this.inboundPb == null) {
+          return
+        }
 
-  /**
-   * Attach a raw inbound stream and setup a read stream
-   */
-  attachInboundStream (stream: Stream, decoderOptions?: DecoderOptions): AsyncIterable<Uint8ArrayList> {
-    const abortListener = (): void => {
-      stream.abort(new AbortError())
-    }
+        const message = await this.inboundPb.read({
+          signal: this.shutDownController.signal
+        })
 
-    this._inboundAbortController.signal.addEventListener('abort', abortListener, {
-      once: true
+        this.safeDispatchEvent('message', {
+          detail: message
+        })
+      }
     })
+      .catch(err => {
+        this.inboundPb?.unwrap().unwrap().abort(err)
+      })
+  }
 
-    // Create and attach a new inbound stream
-    // The inbound stream is:
-    // - abortable, set to only return on abort, rather than throw
-    // - transformed with length-prefix transform
-    this._rawInboundStream = stream
-    this.inboundStream = pipe(
-      this._rawInboundStream,
-      (source) => lp.decode(source, decoderOptions)
-    )
-
-    this.dispatchEvent(new CustomEvent('stream:inbound'))
-    return this.inboundStream
+  attachOutboundStream (stream: Stream, streamOpts?: Partial<ProtobufStreamOpts>): void {
+    this.outboundPb = pbStream(stream, streamOpts).pb(RPC)
   }
 
   /**
-   * Attach a raw outbound stream and setup a write stream
+   * Send a message to this peer
    */
-  async attachOutboundStream (stream: Stream): Promise<Pushable<Uint8ArrayList>> {
-    // If an outbound stream already exists, gently close it
-    const _prevStream = this.outboundStream
-    if (this.outboundStream != null) {
-      // End the stream without emitting a close event
-      this.outboundStream.end()
+  write (message: PubSubRPC): void {
+    if (this.outboundPb == null) {
+      return
     }
 
-    this._rawOutboundStream = stream
-    this.outboundStream = pushable<Uint8ArrayList>({
-      onEnd: (shouldEmit) => {
-        // close writable side of the stream if it exists
-        this._rawOutboundStream?.close()
-          .catch(err => {
-            this.log('error closing outbound stream', err)
-          })
-
-        this._rawOutboundStream = undefined
-        this.outboundStream = undefined
-        if (shouldEmit != null) {
-          this.dispatchEvent(new CustomEvent('close'))
-        }
-      }
+    this.outboundPb.write(message, {
+      signal: this.shutDownController.signal
     })
-
-    pipe(
-      this.outboundStream,
-      (source) => lp.encode(source),
-      async (source) => {
-        for await (const buf of source) {
-          const sendMore = stream.send(buf)
-
-          if (sendMore === false) {
-            await pEvent(stream, 'drain', {
-              rejectionEvents: [
-                'close'
-              ]
-            })
-          }
-        }
-      }
-    ).catch((err: Error) => {
-      this.log.error(err)
-    })
-
-    // Only emit if the connection is new
-    if (_prevStream == null) {
-      this.dispatchEvent(new CustomEvent('stream:outbound'))
-    }
-
-    return this.outboundStream
+      .catch(err => {
+        this.outboundPb?.unwrap().unwrap().abort(err)
+      })
   }
 
   /**
    * Closes the open connection to peer
    */
   close (): void {
-    if (this.closed) {
-      return
-    }
-
-    this.closed = true
-
-    // End the outbound stream
-    if (this.outboundStream != null) {
-      this.outboundStream.end()
-    }
-    // End the inbound stream
-    if (this.inboundStream != null) {
-      this._inboundAbortController.abort()
-    }
-
-    this._rawOutboundStream = undefined
-    this.outboundStream = undefined
-    this._rawInboundStream = undefined
-    this.inboundStream = undefined
-    this.dispatchEvent(new CustomEvent('close'))
+    this.shutDownController.abort()
+
+    Promise.all([
+      this.inboundPb?.unwrap().unwrap().close()
+        .catch(err => {
+          this.inboundPb?.unwrap().unwrap().abort(err)
+        }),
+      this.outboundPb?.unwrap().unwrap().close()
+        .catch(err => {
+          this.inboundPb?.unwrap().unwrap().abort(err)
+        })
+    ])
+      .finally(() => {
+        this.safeDispatchEvent('close')
+      })
   }
 }

package/src/utils.ts

@@ -59,17 +59,6 @@ export const anyMatch = (a: Set<number> | number[], b: Set<number> | number[]):
   return false
 }
 
-/**
- * Make everything an array
- */
-export const ensureArray = function <T> (maybeArray: T | T[]): T[] {
-  if (!Array.isArray(maybeArray)) {
-    return [maybeArray]
-  }
-
-  return maybeArray
-}
-
 const isSigned = async (message: PubSubRPCMessage): Promise<boolean> => {
   if ((message.sequenceNumber == null) || (message.from == null) || (message.signature == null)) {
     return false

package/dist/typedoc-urls.json

@@ -1,41 +0,0 @@
-{
-  "TopicValidatorResult": "https://libp2p.github.io/js-libp2p/enums/_libp2p_floodsub.TopicValidatorResult.html",
-  ".:TopicValidatorResult": "https://libp2p.github.io/js-libp2p/enums/_libp2p_floodsub.TopicValidatorResult.html",
-  "FloodSub": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_floodsub.FloodSub.html",
-  ".:FloodSub": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_floodsub.FloodSub.html",
-  "FloodSubComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_floodsub.FloodSubComponents.html",
-  ".:FloodSubComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_floodsub.FloodSubComponents.html",
-  "FloodSubEvents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_floodsub.FloodSubEvents.html",
-  ".:FloodSubEvents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_floodsub.FloodSubEvents.html",
-  "FloodSubInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_floodsub.FloodSubInit.html",
-  ".:FloodSubInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_floodsub.FloodSubInit.html",
-  "PeerStreamEvents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_floodsub.PeerStreamEvents.html",
-  ".:PeerStreamEvents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_floodsub.PeerStreamEvents.html",
-  "PublishResult": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_floodsub.PublishResult.html",
-  ".:PublishResult": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_floodsub.PublishResult.html",
-  "SignedMessage": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_floodsub.SignedMessage.html",
-  ".:SignedMessage": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_floodsub.SignedMessage.html",
-  "Subscription": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_floodsub.Subscription.html",
-  ".:Subscription": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_floodsub.Subscription.html",
-  "SubscriptionChangeData": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_floodsub.SubscriptionChangeData.html",
-  ".:SubscriptionChangeData": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_floodsub.SubscriptionChangeData.html",
-  "TopicValidatorFn": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_floodsub.TopicValidatorFn.html",
-  ".:TopicValidatorFn": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_floodsub.TopicValidatorFn.html",
-  "UnsignedMessage": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_floodsub.UnsignedMessage.html",
-  ".:UnsignedMessage": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_floodsub.UnsignedMessage.html",
-  "Message": "https://libp2p.github.io/js-libp2p/types/_libp2p_floodsub.Message.html",
-  ".:Message": "https://libp2p.github.io/js-libp2p/types/_libp2p_floodsub.Message.html",
-  "SignaturePolicy": "https://libp2p.github.io/js-libp2p/types/_libp2p_floodsub.SignaturePolicy.html",
-  ".:SignaturePolicy": "https://libp2p.github.io/js-libp2p/types/_libp2p_floodsub.SignaturePolicy.html",
-  "protocol": "https://libp2p.github.io/js-libp2p/variables/_libp2p_floodsub.protocol.html",
-  ".:protocol": "https://libp2p.github.io/js-libp2p/variables/_libp2p_floodsub.protocol.html",
-  "pubSubSymbol": "https://libp2p.github.io/js-libp2p/variables/_libp2p_floodsub.pubSubSymbol.html",
-  "StrictNoSign": "https://libp2p.github.io/js-libp2p/variables/_libp2p_floodsub.StrictNoSign.html",
-  ".:StrictNoSign": "https://libp2p.github.io/js-libp2p/variables/_libp2p_floodsub.StrictNoSign.html",
-  "StrictSign": "https://libp2p.github.io/js-libp2p/variables/_libp2p_floodsub.StrictSign.html",
-  ".:StrictSign": "https://libp2p.github.io/js-libp2p/variables/_libp2p_floodsub.StrictSign.html",
-  "floodsub": "https://libp2p.github.io/js-libp2p/functions/_libp2p_floodsub.floodsub.html",
-  ".:floodsub": "https://libp2p.github.io/js-libp2p/functions/_libp2p_floodsub.floodsub.html",
-  "isPubSub": "https://libp2p.github.io/js-libp2p/functions/_libp2p_floodsub.isPubSub.html",
-  ".:isPubSub": "https://libp2p.github.io/js-libp2p/functions/_libp2p_floodsub.isPubSub.html"
-}