@libp2p/webrtc 1.0.2 → 1.0.3

package/src/muxer.ts

@@ -98,12 +98,9 @@ export class DataChannelMuxer implements StreamMuxer {
     }
   }
 
-  /**
-   * Initiate a new stream with the given name. If no name is
-   * provided, the id of the stream will be used.
-   */
-  newStream (name: string = ''): Stream {
-    const channel = this.peerConnection.createDataChannel(name)
+  newStream (): Stream {
+    // The spec says the label SHOULD be an empty string: https://github.com/libp2p/specs/blob/master/webrtc/README.md#rtcdatachannel-label
+    const channel = this.peerConnection.createDataChannel('')
     const stream = new WebRTCStream({
       channel,
       stat: {

package/src/sdp.ts

@@ -11,12 +11,8 @@ const log = logger('libp2p:webrtc:sdp')
 /**
  * Get base2 | identity decoders
  */
-export const mbdecoder: any = (function () {
-  const decoders = Object.values(bases).map((b) => b.decoder)
-  let acc = decoders[0].or(decoders[1])
-  decoders.slice(2).forEach((d) => (acc = acc.or(d)))
-  return acc
-})()
+// @ts-expect-error - Not easy to combine these types.
+export const mbdecoder: any = Object.values(bases).map(b => b.decoder).reduce((d, b) => d.or(b))
 
 /**
  * Get base2 | identity decoders
@@ -57,7 +53,6 @@ export function decodeCerthash (certhash: string) {
  * Extract the fingerprint from a multiaddr
  */
 export function ma2Fingerprint (ma: Multiaddr): string[] {
-  // certhash_value is a multibase encoded multihash encoded string
   const mhdecoded = decodeCerthash(certhash(ma))
   const prefix = toSupportedHashFunction(mhdecoded.name)
   const fingerprint = mhdecoded.digest.reduce((str, byte) => str + byte.toString(16).padStart(2, '0'), '')

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]
@@ -165,7 +176,7 @@ export class WebRTCStream implements Stream {
   /**
    * The current state of the stream
    */
-   streamState = new StreamState();
+  streamState = new StreamState();
 
   /**
    * Read unwrapped protobuf data from the underlying datachannel.
@@ -177,246 +188,270 @@ export class WebRTCStream implements Stream {
    * 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: 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)
+      }
+    }
+  }
 }