Class QUICServer

Hierarchy

StartStop
- QUICServer

Constructors

constructor

new QUICServer(opts): QUICServer
Constructs a QUIC server.
Parameters
- opts: {
      codeToReason?: StreamCodeToReason;
      config: QUICServerConfigInput;
      crypto: QUICServerCrypto;
      logger?: Logger;
      minIdleTimeout?: number;
      reasonToCode?: StreamReasonToCode;
      resolveHostname?: ResolveHostname;
  }
  - Optional codeToReason?: StreamCodeToReason
    
    maps stream error codes to reasons
  - config: QUICServerConfigInput
    
    defaults to serverDefault
  - crypto: QUICServerCrypto
    
    server needs to be able to sign and verify symmetrically.
  - Optional logger?: Logger
  - Optional minIdleTimeout?: number
    
    can be set to override the starting timeout for accepted connections
  - Optional reasonToCode?: StreamReasonToCode
    
    maps stream error reasons to stream error codes
  - Optional resolveHostname?: ResolveHostname
    
    defaults to using OS DNS resolver
Returns QUICServer
Inherited from startStop.StartStop.constructor
- Defined in src/QUICServer.ts:279
new QUICServer(opts): QUICServer
Parameters
- opts: {
      codeToReason?: StreamCodeToReason;
      config: QUICServerConfigInput;
      crypto: QUICServerCrypto;
      logger?: Logger;
      minIdleTimeout?: number;
      reasonToCode?: StreamReasonToCode;
      socket: QUICSocket;
  }
  - Optional codeToReason?: StreamCodeToReason
  - config: QUICServerConfigInput
  - crypto: QUICServerCrypto
  - Optional logger?: Logger
  - Optional minIdleTimeout?: number
  - Optional reasonToCode?: StreamReasonToCode
  - socket: QUICSocket
Returns QUICServer
Inherited from startStop.StartStop.constructor
- Defined in src/QUICServer.ts:288

Properties

`Readonly` [initLock]

[initLock]: RWLockWriter

`Protected` _closed

_closed: boolean = false

`Protected` _closedP

_closedP: Promise<void>

`Optional` codeToReason

codeToReason?: StreamCodeToReason

Custom code to reason converted for new connections.

`Protected` config

config: QUICConfig

`Protected` crypto

crypto: QUICServerCrypto

`Readonly` isSocketShared

isSocketShared: boolean

Determines if socket is shared.

`Protected` logger

logger: Logger

`Optional` minIdleTimeout

minIdleTimeout?: number

The minimum idle timeout to be used for new connections.

`Optional` reasonToCode

reasonToCode?: StreamReasonToCode

Custom reason to code converter for new connections.

`Protected` resolveClosedP

resolveClosedP: (() => void)

Type declaration

- (): void
- Returns void

`Protected` socket

socket: QUICSocket

`Protected` stopAbortController

stopAbortController: undefined | AbortController

Accessors

[eventHandled]

get [eventHandled](): ReadonlyWeakSet<Event>
Returns ReadonlyWeakSet<Event>
Inherited from startStop.StartStop.[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 startStop.StartStop.[eventHandlers]
- Defined in node_modules/@matrixai/events/dist/Evented.d.ts:6

[eventTarget]

get [eventTarget](): EventTarget
Returns EventTarget
Inherited from startStop.StartStop.[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 startStop.StartStop.[handleEventError]
- Defined in node_modules/@matrixai/events/dist/Evented.d.ts:8

[running]

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

[statusP]

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

[status]

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

closed

get closed(): boolean
Server is no longer accepting connections.

Returns boolean
- Defined in src/QUICServer.ts:353

closedP

get closedP(): Promise<void>
Returns Promise<void>
- Defined in src/QUICServer.ts:357

host

get host(): Host
Returns Host
- Defined in src/QUICServer.ts:340

port

get port(): Port
Returns Port
- Defined in src/QUICServer.ts:345

Methods

addEventListener

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

dispatchEvent

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

`Protected` handleEventQUICConnection

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

`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/QUICServer.ts:185

`Protected` handleEventQUICConnectionStopped

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

`Protected` handleEventQUICServerClose

handleEventQUICServerClose(evt): Promise<void>
Handles EventQUICServerClose. Registered once.

This event propagates errors minus the internal errors.

If this event is dispatched first before QUICServer.stop, it represents an evented close. This could originate from the QUICSocket. If it was from the QUICSocket, then here it will stop all connections with a transport code InternalError.
Parameters
- evt: EventQUICServerClose
Returns Promise<void>
- Defined in src/QUICServer.ts:96

`Protected` handleEventQUICServerError

handleEventQUICServerError(evt): void
Handles EventQUICServerError.

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

Throws
- Defined in src/QUICServer.ts:71

`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/QUICServer.ts:142

`Protected` handleEventQUICSocketStopped

handleEventQUICSocketStopped(): void
Handles EventQUICSocketStopped. Registered once.

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

Returns void
- Defined in src/QUICServer.ts:155

`Protected` mintToken

mintToken(dcid, peerHost): Promise<Buffer>
Creates a retry token. This will embed peer host IP and DCID into the token. It will authenticate the data by providing a signature signed by our key.
Parameters
- dcid: QUICConnectionId
- peerHost: Host
Returns Promise<Buffer>
- Defined in src/QUICServer.ts:704

removeEventListener

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

start

start(opts?): Promise<void>
Starts the QUICServer.
Parameters
- opts: {
      host?: string;
      ipv6Only?: boolean;
      port?: number;
      reuseAddr?: boolean;
  } = {}
  - Optional host?: string
    
    target host, ignored if socket is shared
  - Optional ipv6Only?: boolean
    
    force using IPv6 even when using ::
  - Optional port?: number
    
    target port, ignored if socket is shared
  - Optional reuseAddr?: boolean
    
    reuse existing port
Returns Promise<void>
Inherited from startStop.StartStop.start
- Defined in src/QUICServer.ts:370

stop

stop(opts?): Promise<void>
Stops the QUICServer.
Parameters
- opts: {
      errorCode?: ConnectionErrorCode;
      force?: boolean;
      isApp: false;
      reason?: Uint8Array;
  } | {
      errorCode?: number;
      force?: boolean;
      isApp?: true;
      reason?: Uint8Array;
  } = {}
Returns Promise<void>
Inherited from startStop.StartStop.stop
- Defined in src/QUICServer.ts:431

updateConfig

updateConfig(config): void
Updates the QUICConfig for new connections. It will not affect existing connections, they will keep using the old QUICConfig.
Parameters
- config: Partial<QUICServerConfigInput>
Returns void
- Defined in src/QUICServer.ts:692

updateCrypto

updateCrypto(crypto): void
Parameters
- crypto: Partial<QUICServerCrypto>
Returns void
- Defined in src/QUICServer.ts:680

`Protected` validateToken

validateToken(tokenBuffer, peerHost): Promise<undefined | QUICConnectionId>
Validates the retry token. This will check that the token was signed by us. And it will check that the current host IP is the same as the one put into the token. This proves that the peer can in fact receive and send from the host IP. This returns the DCID inside the token, which was the original DCID.
Parameters
- tokenBuffer: Buffer
- peerHost: Host
Returns Promise<undefined | QUICConnectionId>
- Defined in src/QUICServer.ts:718

Class QUICServer

Hierarchy

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Parameters

opts: { codeToReason?: StreamCodeToReason; config: QUICServerConfigInput; crypto: QUICServerCrypto; logger?: Logger; minIdleTimeout?: number; reasonToCode?: StreamReasonToCode; resolveHostname?: ResolveHostname; }

Optional codeToReason?: StreamCodeToReason

config: QUICServerConfigInput

crypto: QUICServerCrypto

Optional logger?: Logger

Optional minIdleTimeout?: number

Optional reasonToCode?: StreamReasonToCode

Optional resolveHostname?: ResolveHostname

Returns QUICServer

Parameters

opts: { codeToReason?: StreamCodeToReason; config: QUICServerConfigInput; crypto: QUICServerCrypto; logger?: Logger; minIdleTimeout?: number; reasonToCode?: StreamReasonToCode; socket: QUICSocket; }

Optional codeToReason?: StreamCodeToReason

config: QUICServerConfigInput

crypto: QUICServerCrypto

Optional logger?: Logger

Optional minIdleTimeout?: number

Optional reasonToCode?: StreamReasonToCode

socket: QUICSocket

Returns QUICServer

Properties

Readonly [initLock]

Protected _closed

Protected _closedP

Optional codeToReason

Protected config

Protected crypto

Readonly isSocketShared

Protected logger

Optional minIdleTimeout

Optional reasonToCode

Protected resolveClosedP

Type declaration

Returns void

Protected socket

Protected stopAbortController

Accessors

[eventHandled]

Returns ReadonlyWeakSet<Event>

[eventHandlers]

Returns ReadonlyMap<string, Set<EventHandlerInfo>>

[eventTarget]

Returns EventTarget

[handleEventError]

Returns ((evt) => void)

Parameters

evt: EventError

Returns void

[running]

Returns boolean

[statusP]

Returns Promise<Status>

[status]

Returns Status

closed

Returns boolean

closedP

Returns Promise<void>

host

Returns Host

port

Returns Port

Methods

addEventListener

Parameters

type: string

callback: null | EventListenerOrEventListenerObject

Optional options: boolean | AddEventListenerOptions

Returns void

dispatchEvent

Parameters

opts: {
codeToReason?: StreamCodeToReason;
config: QUICServerConfigInput;
crypto: QUICServerCrypto;
logger?: Logger;
minIdleTimeout?: number;
reasonToCode?: StreamReasonToCode;
resolveHostname?: ResolveHostname;
}

`Optional` codeToReason?: StreamCodeToReason

`Optional` logger?: Logger

`Optional` minIdleTimeout?: number

`Optional` reasonToCode?: StreamReasonToCode

`Optional` resolveHostname?: ResolveHostname

opts: {
codeToReason?: StreamCodeToReason;
config: QUICServerConfigInput;
crypto: QUICServerCrypto;
logger?: Logger;
minIdleTimeout?: number;
reasonToCode?: StreamReasonToCode;
socket: QUICSocket;
}

`Optional` codeToReason?: StreamCodeToReason

`Optional` logger?: Logger

`Optional` minIdleTimeout?: number

`Optional` reasonToCode?: StreamReasonToCode

`Readonly` [initLock]

`Protected` _closed

`Protected` _closedP

`Optional` codeToReason

`Protected` config

`Protected` crypto

`Readonly` isSocketShared

`Protected` logger

`Optional` minIdleTimeout

`Optional` reasonToCode

`Protected` resolveClosedP

`Protected` socket

`Protected` stopAbortController

`Optional` options: boolean | AddEventListenerOptions

`Protected` handleEventQUICConnection

`Protected` handleEventQUICConnectionSend

`Protected` handleEventQUICConnectionStopped

`Protected` handleEventQUICServerClose

`Protected` handleEventQUICServerError

`Protected` handleEventQUICSocket

`Protected` handleEventQUICSocketStopped

`Protected` mintToken

`Optional` options: boolean | EventListenerOptions

opts: {
host?: string;
ipv6Only?: boolean;
port?: number;
reuseAddr?: boolean;
} = {}

`Optional` host?: string

`Optional` ipv6Only?: boolean

`Optional` port?: number

`Optional` reuseAddr?: boolean

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

`Protected` validateToken