Class WebSocketStream

Events:

Hierarchy

  • StartStop
    • WebSocketStream

Implements

  • ReadableWritablePair<Uint8Array, Uint8Array>

Constructors

constructor

Properties

[initLock] _readClosed _writeClosed closedP codeToReason connection encodedStreamId initiated logger readable readableController readableQueue readableQueueBufferSize reasonToCode rejectReadableP? rejectWritableP? resolveClosedP resolveReadableP? resolveWritableP? streamId writable writableController writableDesiredSize

Accessors

[eventHandled] [eventHandlers] [eventTarget] [handleEventError] [running] [statusP] [status] closed meta readClosed writeClosed

Methods

addEventListener cancel dispatchEvent handleEventWebSocketStreamCloseRead handleEventWebSocketStreamCloseWrite handleEventWebSocketStreamError readableCancel readablePull readableStart removeEventListener start stop streamSend writableAbort writableClose writableStart writableWrite

Constructors

constructor

Properties

Readonly [initLock]

[initLock]: RWLockWriter

Protected _readClosed

_readClosed: boolean = false

Protected _writeClosed

_writeClosed: boolean = false

Readonly closedP

closedP: Promise<void>

Resolved when the stream has been completely closed (both readable and writable sides).

Protected codeToReason

codeToReason: StreamCodeToReason

Protected connection

connection: WebSocketConnection

Readonly encodedStreamId

encodedStreamId: Uint8Array

Readonly initiated

initiated: "local" | "peer"

Protected logger

logger: Logger

Readonly readable

readable: ReadableStream<Uint8Array>

Errors:

  • errors.ErrorWebSocketStreamClose - This will happen if the stream is closed with stop or if the WebSocketConnection was closed.
  • errors.ErrorWebSocketStreamCancel - This will happen if the stream is closed with cancel
  • errors.ErrorWebSocketStreamUnknown - Unknown error
  • errors.ErrorWebSocketStreamReadableBufferOverload - This will happen when the readable buffer is overloaded
  • errors.ErrorWebSocketStreamReadableParse - This will happen when the ReadableStream cannot parse an incoming message
  • any errors from .cancel(reason)

Protected readableController

readableController: ReadableStreamDefaultController<any>

Protected readableQueue

readableQueue: WebSocketStreamQueue = ...

Protected readableQueueBufferSize

readableQueueBufferSize: number = 0

Protected reasonToCode

reasonToCode: StreamReasonToCode

Protected Optional rejectReadableP

rejectReadableP?: ((reason?: any) => void)

Type declaration

    • (reason?: any): void

    • Parameters

      • Optional reason: any

      Returns void

Protected Optional rejectWritableP

rejectWritableP?: ((reason?: any) => void)

Type declaration

    • (reason?: any): void

    • Parameters

      • Optional reason: any

      Returns void

Protected resolveClosedP

resolveClosedP: (() => void)

Type declaration

    • (): void

    • Returns void

Protected Optional resolveReadableP

resolveReadableP?: (() => void)

Type declaration

    • (): void

    • Returns void

Protected Optional resolveWritableP

resolveWritableP?: (() => void)

Type declaration

    • (): void

    • Returns void

Readonly streamId

streamId: VarInt

Readonly writable

writable: WritableStream<Uint8Array>

Errors:

  • errors.ErrorWebSocketStreamClose - This will happen if the stream is closed with stop or if the WebSocketConnection was closed.
  • errors.ErrorWebSocketStreamCancel - This will happen if the stream is closed with cancel
  • errors.ErrorWebSocketStreamUnknown - Unknown error
  • errors.ErrorWebSocketStreamReadableBufferOverload - This will happen when the receiving ReadableStream's buffer is overloaded
  • errors.ErrorWebSocketStreamReadableParse - This will happen when the receiving ReadableStream cannot parse a sent message
  • any errors from .cancel(reason) or .abort(reason)

Protected writableController

writableController: WritableStreamDefaultController

Protected writableDesiredSize

writableDesiredSize: number = 0

Accessors

[eventHandled]

  • get [eventHandled](): ReadonlyWeakSet<Event>

  • Returns ReadonlyWeakSet<Event>

[eventHandlers]

  • get [eventHandlers](): ReadonlyMap<string, Set<EventHandlerInfo>>

  • Returns ReadonlyMap<string, Set<EventHandlerInfo>>

[eventTarget]

  • get [eventTarget](): EventTarget

  • Returns EventTarget

[handleEventError]

  • get [handleEventError](): ((evt: EventError) => void)

  • Returns ((evt: EventError) => void)

      • (evt: EventError): void

      • Parameters

        • evt: EventError

        Returns void

[running]

  • get [running](): boolean

  • Returns boolean

[statusP]

  • get [statusP](): Promise<Status>

  • Returns Promise<Status>

[status]

  • get [status](): Status

  • Returns Status

closed

  • get closed(): boolean

  • Whether the stream has been completely closed (both readable and writable sides).

    Returns boolean

meta

readClosed

writeClosed

Methods

addEventListener

  • Parameters

    • type: string
    • callback: null | EventListenerOrEventListenerObject
    • Optional options: boolean | AddEventListenerOptions

    Returns void

cancel

  • Will trigger the destruction of the WebSocketStream if the readable or writable haven't closed, yet they will be forced closed with reason as the error. If streams have already closed then this will do nothing. This is synchronous by design but cancelling will happen asynchronously in the background.

    This ends up calling the cancel and abort methods. Those methods are needed because the readable and writable might be locked with a reader and writer respectively. So we have to cancel and abort from the "inside" of the stream. It's essential that this is synchronous, as that ensures only one thing is running at a time. Note that if cancellation fails...

    Calling this will lead an asynchronous destruction of this WebSocketStream instance. This could throw actually. But cancellation is likely to have occurred.

    Parameters

    • Optional reason: any

    Returns void

dispatchEvent

  • Parameters

    • event: Event

    Returns boolean

Protected handleEventWebSocketStreamCloseRead

Protected handleEventWebSocketStreamCloseWrite

Protected handleEventWebSocketStreamError

  • We expect WebSocket stream error in 2 ways. WebSocket stream closure of the stream codes. On read side On write side We are able to use exception classes to distinguish things Because it's always about the error itself!A Note that you must distinguish between actual internal errors, and errors on the stream itself

    Parameters

    Returns Promise<void>

Protected readableCancel

  • This is factored out and callable by both readable.cancel and this.cancel. ReadableStream ensures that this method is idempotent

    Throws

    Parameters

    • Optional reason: any

    Returns void

Protected readablePull

  • Parameters

    • controller: ReadableStreamDefaultController<any>

    Returns Promise<void>

Protected readableStart

  • Parameters

    • controller: ReadableStreamDefaultController<any>

    Returns void

removeEventListener

  • Parameters

    • type: string
    • callback: null | EventListenerOrEventListenerObject
    • Optional options: boolean | EventListenerOptions

    Returns void

start

stop

  • This method can be arrived top-down or bottom-up:

    1. Top-down control flow - means explicit destruction from WebSocketConnection
    2. Bottom-up control flow - means stream events from users of this stream

    If force is true then this will cancel readable and abort writable. If force is false then it will just wait for readable and writable to be closed.

    Unlike WebSocketConnection, this defaults to true for force.

    Parameters

    • __namedParameters: {
          force?: boolean;
          reason?: any;
      } = {}
      • Optional force?: boolean
      • Optional reason?: any

    Returns Promise<void>

Protected streamSend

Protected writableAbort

  • This is factored out and callable by both writable.abort and this.cancel.

    Parameters

    • Optional reason: any

    Returns void

Protected writableClose

  • This is mutually exclusive with write. It will be serialised!

    Returns void

Protected writableStart

  • Parameters

    • controller: WritableStreamDefaultController

    Returns void

Protected writableWrite

  • Parameters

    • chunk: Uint8Array

    Returns Promise<void>

Settings

Member Visibility

Theme

Generated using TypeDoc