Class QUICClient

Hierarchy

CreateDestroy
- QUICClient

Constructors

constructor

new QUICClient(__namedParameters): QUICClient
Parameters
- __namedParameters: {
      connection: QUICConnection;
      isSocketShared: boolean;
      logger: Logger;
      socket: QUICSocket;
  }
  - connection: QUICConnection
  - isSocketShared: boolean
  - logger: Logger
  - socket: QUICSocket
Returns QUICClient
Inherited from createDestroy.CreateDestroy.constructor
- Defined in src/QUICClient.ts:587

Properties

`Readonly` [initLock]

[initLock]: RWLockWriter

`Protected` _closed

_closed: boolean = false

`Readonly` closedP

closedP: Promise<void>

`Protected` config

config: Config

`Readonly` connection

connection: QUICConnection

`Readonly` isSocketShared

isSocketShared: boolean

`Protected` logger

logger: Logger

`Protected` resolveClosedP

resolveClosedP: (() => void)

Type declaration

- (): void
- Returns void

`Protected` socket

socket: QUICSocket

Accessors

[destroyed]

get [destroyed](): boolean
Returns boolean
Inherited from createDestroy.CreateDestroy.[destroyed]
- Defined in node_modules/@matrixai/async-init/dist/CreateDestroy.d.ts:6

[eventHandled]

get [eventHandled](): ReadonlyWeakSet<Event>
Returns ReadonlyWeakSet<Event>
Inherited from createDestroy.CreateDestroy.[eventHandled]
- Defined in node_modules/@matrixai/events/dist/Evented.d.ts:7

[eventHandlers]

get [eventHandlers](): ReadonlyMap<string, Set<EventHandlerInfo>>
Returns ReadonlyMap<string, Set<EventHandlerInfo>>
Inherited from createDestroy.CreateDestroy.[eventHandlers]
- Defined in node_modules/@matrixai/events/dist/Evented.d.ts:6

[eventTarget]

get [eventTarget](): EventTarget
Returns EventTarget
Inherited from createDestroy.CreateDestroy.[eventTarget]
- Defined in node_modules/@matrixai/events/dist/Evented.d.ts:5

[handleEventError]

get [handleEventError](): ((evt) => void)
Returns ((evt) => void)
- - (evt): void
  - Parameters
    - evt: EventError
    Returns void
Inherited from createDestroy.CreateDestroy.[handleEventError]
- Defined in node_modules/@matrixai/events/dist/Evented.d.ts:8

[statusP]

get [statusP](): Promise<Status>
Returns Promise<Status>
Inherited from createDestroy.CreateDestroy.[statusP]
- Defined in node_modules/@matrixai/async-init/dist/CreateDestroy.d.ts:8

[status]

get [status](): Status
Returns Status
Inherited from createDestroy.CreateDestroy.[status]
- Defined in node_modules/@matrixai/async-init/dist/CreateDestroy.d.ts:7

closed

get closed(): boolean
Returns boolean
- Defined in src/QUICClient.ts:627

host

get host(): Host
Returns Host
- Defined in src/QUICClient.ts:607

localHost

get localHost(): Host
Returns Host
- Defined in src/QUICClient.ts:617

localPort

get localPort(): Port
Returns Port
- Defined in src/QUICClient.ts:622

port

get port(): Port
Returns Port
- Defined in src/QUICClient.ts:612

Methods

addEventListener

addEventListener(type, callback, options?): void
Parameters
- type: string
- callback: null | EventListenerOrEventListenerObject
- Optional options: boolean | AddEventListenerOptions
Returns void
Inherited from createDestroy.CreateDestroy.addEventListener
- Defined in node_modules/@matrixai/events/dist/Evented.d.ts:9

destroy

destroy(opts?): Promise<void>
Destroy the QUICClient.
Parameters
- opts: {
      errorCode?: ConnectionErrorCode;
      force?: boolean;
      isApp: false;
      reason?: Uint8Array;
  } | {
      errorCode?: number;
      force?: boolean;
      isApp?: true;
      reason?: Uint8Array;
  } = {}
Returns Promise<void>
Inherited from createDestroy.CreateDestroy.destroy
- Defined in src/QUICClient.ts:641

dispatchEvent

dispatchEvent(event): boolean
Parameters
- event: Event
Returns boolean
Inherited from createDestroy.CreateDestroy.dispatchEvent
- Defined in node_modules/@matrixai/events/dist/Evented.d.ts:11

`Protected` handleEventQUICClientClose

handleEventQUICClientClose(evt): Promise<void>
Handles EventQUICClientClose. Registered once.

This event propagates errors minus the internal errors. All QUIC connections always close with an error, even if it is a graceful.

If this event is dispatched first before QUICClient.destroy, it represents an evented close. This could originate from the QUICSocket or QUICConnection. If it was from the QUICSocket, then here it will stop the QUICConnection with a transport code InternalError. If it was from QUICConnection, then the QUICConnection will already be closing. Therefore, attempting to stop the QUICConnection will be idempotent.
Parameters
- evt: EventQUICClientClose
Returns Promise<void>
- Defined in src/QUICClient.ts:396

`Protected` handleEventQUICClientError

handleEventQUICClientError(evt): void
Handles EventQUICClientError.

This event propagates all errors from QUICClient and QUICConnection. This means you can expect that QUICConnection errors will be logged twice.

Internal errors will be thrown upwards to become an uncaught exception.
Parameters
- evt: EventQUICClientError
Returns void

Throws

Throws
- Defined in src/QUICClient.ts:365

`Protected` handleEventQUICConnection

handleEventQUICConnection(evt): void
Handles all EventQUICConnection events.
Parameters
- evt: EventAll<Event>
Returns void
- Defined in src/QUICClient.ts:477

`Protected` handleEventQUICConnectionError

handleEventQUICConnectionError(evt): void
Handles EventQUICConnectionError.

All connection errors are redispatched as client errors.
Parameters
- evt: EventQUICConnectionError
Returns void
- Defined in src/QUICClient.ts:488

`Protected` handleEventQUICConnectionSend

handleEventQUICConnectionSend(evt): Promise<void>
Handles EventQUICConnectionSend.

This will propagate the connection send buffers to the socket. This may be concurrent and multiple send events may be processed at a time.
Parameters
- evt: EventQUICConnectionSend
Returns Promise<void>
- Defined in src/QUICClient.ts:502

`Protected` handleEventQUICConnectionStopped

handleEventQUICConnectionStopped(evt): void
Handles EventQUICConnectionStopped. Registered once.
Parameters
- evt: EventQUICConnectionStopped
Returns void
- Defined in src/QUICClient.ts:568

`Protected` handleEventQUICSocket

handleEventQUICSocket(evt): void
Handles all EventQUICSocket events. Registered only if the socket is encapsulated.
Parameters
- evt: EventAll<Event>
Returns void
- Defined in src/QUICClient.ts:447

`Protected` handleEventQUICSocketStopped

handleEventQUICSocketStopped(): void
Handles EventQUICSocketStopped. Registered once.

It is an error if the socket was stopped while QUICClient wasn't destroyed.

Returns void
- Defined in src/QUICClient.ts:464

removeEventListener

removeEventListener(type, callback, options?): void
Parameters
- type: string
- callback: null | EventListenerOrEventListenerObject
- Optional options: boolean | EventListenerOptions
Returns void
Inherited from createDestroy.CreateDestroy.removeEventListener
- Defined in node_modules/@matrixai/events/dist/Evented.d.ts:10

`Static` createQUICClient

createQUICClient(opts, ctx?): PromiseCancellable<QUICClient>
Creates a QUIC client.
Parameters
- opts: {
      codeToReason?: StreamCodeToReason;
      config?: Partial<QUICConfig>;
      crypto: QUICClientCrypto;
      host: string;
      ipv6Only?: boolean;
      localHost?: string;
      localPort?: number;
      logger?: Logger;
      port: number;
      reasonToCode?: StreamReasonToCode;
      resolveHostname?: ResolveHostname;
      reuseAddr?: boolean;
      serverName?: string;
  }
  - Optional codeToReason?: StreamCodeToReason
    
    maps stream error codes to reasons
  - Optional config?: Partial<QUICConfig>
    
    defaults to clientDefault
  - crypto: QUICClientCrypto
    
    client needs to generate random bytes
  - host: string
    
    target host where wildcards are resolved to point locally.
  - Optional ipv6Only?: boolean
    
    force using IPv6 even when using ::
  - Optional localHost?: string
    
    defaults to :: (dual-stack)
  - Optional localPort?: number
    
    defaults 0
  - Optional logger?: Logger
  - port: number
    
    target port
  - Optional reasonToCode?: StreamReasonToCode
    
    maps stream error reasons to stream error codes
  - Optional resolveHostname?: ResolveHostname
    
    defaults to using OS DNS resolver
  - Optional reuseAddr?: boolean
    
    reuse existing port
  - Optional serverName?: string
    
    The expected name of the server you are connecting to, defaults to host.
- Optional ctx: Partial<ContextTimedInput>
Returns PromiseCancellable<QUICClient>
Throws
- if timed out
Throws
- if shared socket is not running
Throws
- if local host is incompatible with target host
Throws
- if socket start failed
Throws
- if connection start failed
- Defined in src/QUICClient.ts:59
createQUICClient(opts, ctx?): PromiseCancellable<QUICClient>
Parameters
- opts: {
      codeToReason?: StreamCodeToReason;
      config?: Partial<QUICConfig>;
      crypto: QUICClientCrypto;
      host: string;
      ipv6Only?: boolean;
      logger?: Logger;
      port: number;
      reasonToCode?: StreamReasonToCode;
      reuseAddr?: boolean;
      serverName?: string;
      socket: QUICSocket;
  }
  - Optional codeToReason?: StreamCodeToReason
  - Optional config?: Partial<QUICConfig>
  - crypto: QUICClientCrypto
  - host: string
  - Optional ipv6Only?: boolean
  - Optional logger?: Logger
  - port: number
  - Optional reasonToCode?: StreamReasonToCode
  - Optional reuseAddr?: boolean
  - Optional serverName?: string
  - socket: QUICSocket
- Optional ctx: Partial<ContextTimedInput>
Returns PromiseCancellable<QUICClient>
- Defined in src/QUICClient.ts:77

Class QUICClient

Hierarchy

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Parameters

__namedParameters: { connection: QUICConnection; isSocketShared: boolean; logger: Logger; socket: QUICSocket; }

connection: QUICConnection

isSocketShared: boolean

logger: Logger

socket: QUICSocket

Returns QUICClient

Properties

Readonly [initLock]

Protected _closed

Readonly closedP

Protected config

Readonly connection

Readonly isSocketShared

Protected logger

Protected resolveClosedP

Type declaration

Returns void

Protected socket

Accessors

[destroyed]

Returns boolean

[eventHandled]

Returns ReadonlyWeakSet<Event>

[eventHandlers]

Returns ReadonlyMap<string, Set<EventHandlerInfo>>

[eventTarget]

Returns EventTarget

[handleEventError]

Returns ((evt) => void)

Parameters

evt: EventError

Returns void

[statusP]

Returns Promise<Status>

[status]

Returns Status

closed

Returns boolean

host

Returns Host

localHost

Returns Host

localPort

Returns Port

port

Returns Port

Methods

addEventListener

Parameters

type: string

callback: null | EventListenerOrEventListenerObject

Optional options: boolean | AddEventListenerOptions

Returns void

destroy

Parameters

opts: { errorCode?: ConnectionErrorCode; force?: boolean; isApp: false; reason?: Uint8Array; } | { errorCode?: number; force?: boolean; isApp?: true; reason?: Uint8Array; } = {}

Returns Promise<void>

dispatchEvent

Parameters

event: Event

Returns boolean

Protected handleEventQUICClientClose

Parameters

evt: EventQUICClientClose

Returns Promise<void>

Protected handleEventQUICClientError

Parameters

evt: EventQUICClientError

Returns void

Throws

__namedParameters: {
connection: QUICConnection;
isSocketShared: boolean;
logger: Logger;
socket: QUICSocket;
}

`Readonly` [initLock]

`Protected` _closed

`Readonly` closedP

`Protected` config

`Readonly` connection

`Readonly` isSocketShared

`Protected` logger

`Protected` resolveClosedP

`Protected` socket

`Optional` options: boolean | AddEventListenerOptions

opts: {
errorCode?: ConnectionErrorCode;
force?: boolean;
isApp: false;
reason?: Uint8Array;
} | {
errorCode?: number;
force?: boolean;
isApp?: true;
reason?: Uint8Array;
} = {}

`Protected` handleEventQUICClientClose

`Protected` handleEventQUICClientError

`Protected` handleEventQUICConnection

`Protected` handleEventQUICConnectionError

`Protected` handleEventQUICConnectionSend

`Protected` handleEventQUICConnectionStopped

`Protected` handleEventQUICSocket

`Protected` handleEventQUICSocketStopped

`Optional` options: boolean | EventListenerOptions

`Static` createQUICClient

`Optional` codeToReason?: StreamCodeToReason

`Optional` config?: Partial<QUICConfig>

`Optional` ipv6Only?: boolean

`Optional` localHost?: string

`Optional` localPort?: number

`Optional` logger?: Logger

`Optional` reasonToCode?: StreamReasonToCode

`Optional` resolveHostname?: ResolveHostname

`Optional` reuseAddr?: boolean

`Optional` serverName?: string

`Optional` ctx: Partial<ContextTimedInput>

opts: {
codeToReason?: StreamCodeToReason;
config?: Partial<QUICConfig>;
crypto: QUICClientCrypto;
host: string;
ipv6Only?: boolean;
logger?: Logger;
port: number;
reasonToCode?: StreamReasonToCode;
reuseAddr?: boolean;
serverName?: string;
socket: QUICSocket;
}

`Optional` codeToReason?: StreamCodeToReason

`Optional` config?: Partial<QUICConfig>

`Optional` ipv6Only?: boolean

`Optional` logger?: Logger

`Optional` reasonToCode?: StreamReasonToCode

`Optional` reuseAddr?: boolean

`Optional` serverName?: string

`Optional` ctx: Partial<ContextTimedInput>