@libp2p/webrtc 1.0.2 → 1.0.4

package/src/stream.ts

@@ -5,7 +5,7 @@ import merge from 'it-merge'
 import { pipe } from 'it-pipe'
 import { pushable } from 'it-pushable'
 import defer, { DeferredPromise } from 'p-defer'
-import type { Source, Sink } from 'it-stream-types'
+import type { Source } from 'it-stream-types'
 import { Uint8ArrayList } from 'uint8arraylist'
 
 import * as pb from '../proto_ts/message.js'
@@ -61,7 +61,7 @@ interface StreamStateInput {
   direction: 'inbound' | 'outbound'
 
   /**
-   * Message flag from the protobuffs
+   * Message flag from the protobufs
    *
    * 0 = FIN
    * 1 = STOP_SENDING
@@ -77,9 +77,19 @@ export enum StreamStates {
   CLOSED,
 }
 
+// Checked by the Typescript compiler. If this fails it's because the switch
+// statement is not exhaustive.
+function unreachableBranch (x: never): never {
+  throw new Error('Case not handled in switch')
+}
+
 class StreamState {
   state: StreamStates = StreamStates.OPEN
 
+  isWriteClosed (): boolean {
+    return (this.state === StreamStates.CLOSED || this.state === StreamStates.WRITE_CLOSED)
+  }
+
   transition ({ direction, flag }: StreamStateInput): [StreamStates, StreamStates] {
     const prev = this.state
 
@@ -109,8 +119,8 @@ class StreamState {
         case pb.Message_Flag.RESET:
           this.state = StreamStates.CLOSED
           break
-
-        // no default
+        default:
+          unreachableBranch(flag)
       }
     } else {
       switch (flag) {
@@ -134,7 +144,8 @@ class StreamState {
           this.state = StreamStates.CLOSED
           break
 
-        // no default
+        default:
+          unreachableBranch(flag)
       }
     }
     return [prev, this.state]
@@ -145,278 +156,302 @@ export class WebRTCStream implements Stream {
   /**
    * Unique identifier for a stream
    */
-  id: string;
+  id: string
 
   /**
    * Stats about this stream
    */
-  stat: StreamStat;
+  stat: StreamStat
 
   /**
    * User defined stream metadata
    */
-  metadata: Record<string, any>;
+  metadata: Record<string, any>
 
   /**
    * The data channel used to send and receive data
    */
-  private readonly channel: RTCDataChannel;
+  private readonly channel: RTCDataChannel
 
   /**
    * The current state of the stream
    */
-   streamState = new StreamState();
+  streamState = new StreamState()
 
   /**
    * Read unwrapped protobuf data from the underlying datachannel.
    * _src is exposed to the user via the `source` getter to .
    */
-  private readonly _src: Source<Uint8ArrayList>;
+  private readonly _src: Source<Uint8ArrayList>
 
   /**
    * push data from the underlying datachannel to the length prefix decoder
    * and then the protobuf decoder.
    */
-   private readonly _innersrc = pushable();
-
-   /**
-    * Write data to the remote peer.
-    * It takes care of wrapping data in a protobuf and adding the length prefix.
-    */
-   sink: Sink<Uint8ArrayList | Uint8Array, Promise<void>>;
-
-   /**
-    * Deferred promise that resolves when the underlying datachannel is in the
-    * open state.
-    */
-   opened: DeferredPromise<void> = defer();
-
-   /**
-    * Triggers a generator which can be used to close the sink.
-    */
-   closeWritePromise: DeferredPromise<void> = defer();
-
-   /**
-    * Callback to invoke when the stream is closed.
-    */
-   closeCb?: (stream: WebRTCStream) => void
-
-   constructor (opts: StreamInitOpts) {
-     this.channel = opts.channel
-     this.id = this.channel.label
-
-     this.stat = opts.stat
-     switch (this.channel.readyState) {
-       case 'open':
-         this.opened.resolve()
-         break
-
-       case 'closed':
-       case 'closing':
-         this.streamState.state = StreamStates.CLOSED
-         if (this.stat.timeline.close === undefined || this.stat.timeline.close === 0) {
-           this.stat.timeline.close = new Date().getTime()
-         }
-         this.opened.resolve()
-         break
-
-       // no default
-     }
-
-     this.metadata = opts.metadata ?? {}
-
-     // closable sink
-     this.sink = this._sinkFn
-
-     // handle RTCDataChannel events
-     this.channel.onopen = (_evt) => {
-       this.stat.timeline.open = new Date().getTime()
-       this.opened.resolve()
-     }
-
-     this.channel.onclose = (_evt) => {
-       this.close()
-     }
-
-     this.channel.onerror = (evt) => {
-       const err = (evt as RTCErrorEvent).error
-       this.abort(err)
-     }
-
-     const self = this
-
-     // reader pipe
-     this.channel.onmessage = async ({ data }) => {
-       if (data === null || data.length === 0) {
-         return
-       }
-       this._innersrc.push(new Uint8Array(data as ArrayBufferLike))
-     }
-
-     // pipe framed protobuf messages through a length prefixed decoder, and
-     // surface data from the `Message.message` field through a source.
-     this._src = pipe(
-       this._innersrc,
-       lengthPrefixed.decode(),
-       (source) => (async function * () {
-         for await (const buf of source) {
-           const message = self.processIncomingProtobuf(buf.subarray())
-           if (message != null) {
-             yield new Uint8ArrayList(message)
-           }
-         }
-       })()
-     )
-   }
-
-   // If user attempts to set a new source this should be a noop
-   set source (_src: Source<Uint8ArrayList>) { }
-
-   get source (): Source<Uint8ArrayList> {
-     return this._src
-   }
-
-   /**
-    * Closable sink
-    */
-   private async _sinkFn (src: Source<Uint8ArrayList | Uint8Array>): Promise<void> {
-     await this.opened.promise
-
-     const isClosed = (state: StreamStates) => state === StreamStates.CLOSED || state === StreamStates.WRITE_CLOSED
-
-     if (isClosed(this.streamState.state)) {
-       return
-     }
-
-     const self = this
-     const closeWriteIterable = {
-       async * [Symbol.asyncIterator] () {
-         await self.closeWritePromise.promise
-         yield new Uint8Array(0)
-       }
-     }
-
-     for await (const buf of merge(closeWriteIterable, src)) {
-       if (isClosed(self.streamState.state)) {
-         return
-       }
-
-       const msgbuf = pb.Message.toBinary({ message: buf.subarray() })
-       const sendbuf = lengthPrefixed.encode.single(msgbuf)
-
-       this.channel.send(sendbuf.subarray())
-     }
-   }
-
-   /**
-    * Handle incoming
-    */
-   processIncomingProtobuf (buffer: Uint8Array): Uint8Array | undefined {
-     const message = pb.Message.fromBinary(buffer)
-
-     if (message.flag !== undefined) {
-       const [currentState, nextState] = this.streamState.transition({ direction: 'inbound', flag: message.flag })
-
-       if (currentState !== nextState) {
-         // @TODO(ddimaria): determine if we need to check for StreamStates.OPEN
-         switch (nextState) {
-           case StreamStates.READ_CLOSED:
-             this._innersrc.end()
-             break
-           case StreamStates.WRITE_CLOSED:
-             this.closeWritePromise.resolve()
-             break
-           case StreamStates.CLOSED:
-             this.close()
-             break
-
-             // no default
-         }
-       }
-     }
-
-     return message.message
-   }
-
-   /**
-    * Close a stream for reading and writing
-    */
-   close (): void {
-     this.stat.timeline.close = new Date().getTime()
-     this.streamState.state = StreamStates.CLOSED
-     this._innersrc.end()
-     this.closeWritePromise.resolve()
-     this.channel.close()
-
-     if (this.closeCb !== undefined) {
-       this.closeCb(this)
-     }
-   }
-
-   /**
-    * Close a stream for reading only
-    */
-   closeRead (): void {
-     const [currentState, nextState] = this.streamState.transition({ direction: 'outbound', flag: pb.Message_Flag.STOP_SENDING })
-
-     if (currentState === StreamStates.OPEN || currentState === StreamStates.WRITE_CLOSED) {
-       this._sendFlag(pb.Message_Flag.STOP_SENDING);
-       (this._innersrc).end()
-     }
-
-     if (currentState !== nextState && nextState === StreamStates.CLOSED) {
-       this.close()
-     }
-   }
-
-   /**
-    * Close a stream for writing only
-    */
-   closeWrite (): void {
-     const [currentState, nextState] = this.streamState.transition({ direction: 'outbound', flag: pb.Message_Flag.FIN })
-
-     if (currentState === StreamStates.OPEN || currentState === StreamStates.READ_CLOSED) {
-       this._sendFlag(pb.Message_Flag.FIN)
-       this.closeWritePromise.resolve()
-     }
-
-     if (currentState !== nextState && nextState === StreamStates.CLOSED) {
-       this.close()
-     }
-   }
-
-   /**
-    * Call when a local error occurs, should close the stream for reading and writing
-    */
-   abort (err: Error): void {
-     log.error(`An error occurred, clost the stream for reading and writing: ${err.message}`)
-     this.close()
-   }
-
-   /**
-    * Close the stream for writing, and indicate to the remote side this is being done 'abruptly'
-    *
-    * @see closeWrite
-    */
-   reset (): void {
-     this.stat = defaultStat(this.stat.direction)
-     const [currentState, nextState] = this.streamState.transition({ direction: 'outbound', flag: pb.Message_Flag.RESET })
-
-     if (currentState !== nextState) {
-       this._sendFlag(pb.Message_Flag.RESET)
-       this.close()
-     }
-   }
-
-   private _sendFlag (flag: pb.Message_Flag): void {
-     try {
-       log.trace('Sending flag: %s', flag.toString())
-       const msgbuf = pb.Message.toBinary({ flag: flag })
-       this.channel.send(lengthPrefixed.encode.single(msgbuf).subarray())
-     } catch (err) {
-       if (err instanceof Error) {
-         log.error(`Exception while sending flag ${flag}: ${err.message}`)
-       }
-     }
-   }
+  private readonly _innersrc = pushable()
+
+  /**
+   * Deferred promise that resolves when the underlying datachannel is in the
+   * open state.
+   */
+  opened: DeferredPromise<void> = defer()
+
+  /**
+   * sinkCreated is set to true once the sinkFunction is invoked
+   */
+  _sinkCalled: boolean = false
+
+  /**
+   * Triggers a generator which can be used to close the sink.
+   */
+  closeWritePromise: DeferredPromise<void> = defer()
+
+  /**
+   * Callback to invoke when the stream is closed.
+   */
+  closeCb?: (stream: WebRTCStream) => void
+
+  constructor (opts: StreamInitOpts) {
+    this.channel = opts.channel
+    this.id = this.channel.label
+
+    this.stat = opts.stat
+    switch (this.channel.readyState) {
+      case 'open':
+        this.opened.resolve()
+        break
+
+      case 'closed':
+      case 'closing':
+        this.streamState.state = StreamStates.CLOSED
+        if (this.stat.timeline.close === undefined || this.stat.timeline.close === 0) {
+          this.stat.timeline.close = new Date().getTime()
+        }
+        this.opened.resolve()
+        break
+      case 'connecting':
+        // noop
+        break
+
+      default:
+        unreachableBranch(this.channel.readyState)
+    }
+
+    this.metadata = opts.metadata ?? {}
+
+    // handle RTCDataChannel events
+    this.channel.onopen = (_evt) => {
+      this.stat.timeline.open = new Date().getTime()
+      this.opened.resolve()
+    }
+
+    this.channel.onclose = (_evt) => {
+      this.close()
+    }
+
+    this.channel.onerror = (evt) => {
+      const err = (evt as RTCErrorEvent).error
+      this.abort(err)
+    }
+
+    const self = this
+
+    // reader pipe
+    this.channel.onmessage = async ({ data }) => {
+      if (data === null || data.length === 0) {
+        return
+      }
+      this._innersrc.push(new Uint8Array(data as ArrayBufferLike))
+    }
+
+    // pipe framed protobuf messages through a length prefixed decoder, and
+    // surface data from the `Message.message` field through a source.
+    this._src = pipe(
+      this._innersrc,
+      lengthPrefixed.decode(),
+      (source) => (async function * () {
+        for await (const buf of source) {
+          const message = self.processIncomingProtobuf(buf.subarray())
+          if (message != null) {
+            yield new Uint8ArrayList(message)
+          }
+        }
+      })()
+    )
+  }
+
+  // If user attempts to set a new source this should be a noop
+  set source (_src: Source<Uint8ArrayList>) { }
+
+  get source (): Source<Uint8ArrayList> {
+    return this._src
+  }
+
+  /**
+   * Write data to the remote peer.
+   * It takes care of wrapping data in a protobuf and adding the length prefix.
+   */
+  async sink (src: Source<Uint8ArrayList | Uint8Array>): Promise<void> {
+    if (this._sinkCalled) {
+      throw new Error('sink already called on this stream')
+    }
+    // await stream opening before sending data
+    await this.opened.promise
+    try {
+      await this._sink(src)
+    } finally {
+      this.closeWrite()
+    }
+  }
+
+  /**
+   * Closable sink implementation
+   */
+  private async _sink (src: Source<Uint8ArrayList | Uint8Array>): Promise<void> {
+    const closeWrite = this._closeWriteIterable()
+    for await (const buf of merge(closeWrite, src)) {
+      if (this.streamState.isWriteClosed()) {
+        return
+      }
+      const msgbuf = pb.Message.toBinary({ message: buf.subarray() })
+      const sendbuf = lengthPrefixed.encode.single(msgbuf)
+
+      this.channel.send(sendbuf.subarray())
+    }
+  }
+
+  /**
+   * Handle incoming
+   */
+  processIncomingProtobuf (buffer: Uint8Array): Uint8Array | undefined {
+    const message = pb.Message.fromBinary(buffer)
+
+    if (message.flag !== undefined) {
+      const [currentState, nextState] = this.streamState.transition({ direction: 'inbound', flag: message.flag })
+
+      if (currentState !== nextState) {
+        switch (nextState) {
+          case StreamStates.READ_CLOSED:
+            this._innersrc.end()
+            break
+          case StreamStates.WRITE_CLOSED:
+            this.closeWritePromise.resolve()
+            break
+          case StreamStates.CLOSED:
+            this.close()
+            break
+          // StreamStates.OPEN will never be a nextState
+          case StreamStates.OPEN:
+            break
+          default:
+            unreachableBranch(nextState)
+        }
+      }
+    }
+
+    return message.message
+  }
+
+  /**
+   * Close a stream for reading and writing
+   */
+  close (): void {
+    this.stat.timeline.close = new Date().getTime()
+    this.streamState.state = StreamStates.CLOSED
+    this._innersrc.end()
+    this.closeWritePromise.resolve()
+    this.channel.close()
+
+    if (this.closeCb !== undefined) {
+      this.closeCb(this)
+    }
+  }
+
+  /**
+   * Close a stream for reading only
+   */
+  closeRead (): void {
+    const [currentState, nextState] = this.streamState.transition({ direction: 'outbound', flag: pb.Message_Flag.STOP_SENDING })
+    if (currentState === nextState) {
+      // No change, no op
+      return
+    }
+
+    if (currentState === StreamStates.OPEN || currentState === StreamStates.WRITE_CLOSED) {
+      this._sendFlag(pb.Message_Flag.STOP_SENDING)
+      this._innersrc.end()
+    }
+
+    if (nextState === StreamStates.CLOSED) {
+      this.close()
+    }
+  }
+
+  /**
+   * Close a stream for writing only
+   */
+  closeWrite (): void {
+    const [currentState, nextState] = this.streamState.transition({ direction: 'outbound', flag: pb.Message_Flag.FIN })
+    if (currentState === nextState) {
+      // No change, no op
+      return
+    }
+
+    if (currentState === StreamStates.OPEN || currentState === StreamStates.READ_CLOSED) {
+      this._sendFlag(pb.Message_Flag.FIN)
+      this.closeWritePromise.resolve()
+    }
+
+    if (nextState === StreamStates.CLOSED) {
+      this.close()
+    }
+  }
+
+  /**
+   * Call when a local error occurs, should close the stream for reading and writing
+   */
+  abort (err: Error): void {
+    log.error(`An error occurred, closing the stream for reading and writing: ${err.message}`)
+    this.close()
+  }
+
+  /**
+   * Close the stream for writing, and indicate to the remote side this is being done 'abruptly'
+   *
+   * @see this.closeWrite
+   */
+  reset (): void {
+    // TODO Why are you resetting the stat here?
+    this.stat = defaultStat(this.stat.direction)
+    const [currentState, nextState] = this.streamState.transition({ direction: 'outbound', flag: pb.Message_Flag.RESET })
+    if (currentState === nextState) {
+      // No change, no op
+      return
+    }
+
+    this._sendFlag(pb.Message_Flag.RESET)
+    this.close()
+  }
+
+  private _sendFlag (flag: pb.Message_Flag): void {
+    try {
+      log.trace('Sending flag: %s', flag.toString())
+      const msgbuf = pb.Message.toBinary({ flag })
+      this.channel.send(lengthPrefixed.encode.single(msgbuf).subarray())
+    } catch (err) {
+      if (err instanceof Error) {
+        log.error(`Exception while sending flag ${flag}: ${err.message}`)
+      }
+    }
+  }
+
+  private _closeWriteIterable (): Source<Uint8ArrayList | Uint8Array> {
+    const self = this
+    return {
+      async * [Symbol.asyncIterator] () {
+        await self.closeWritePromise.promise
+        yield new Uint8Array(0)
+      }
+    }
+  }
 }