moonbitstack/moonasgi/ws

README
U
AsgiApp
U
AsgiAppInstance
U
AsgiApplication
U
AsgiVersion
U
ConformanceReport
U
Drain
U
Event
U
EventOrderError
U
Extensions
U
Handler
U
Http2HeaderError
U
HttpScope
U
LegacyAsgiApp
U
LifespanHandler
U
LifespanReply
U
LifespanScope
U
Middleware
U
PushPromise
U
Receive
U
Request
U
Response
U
Scope
U
Send
U
StreamHandler
U
StreamingResponse
U
TestClient
U
TestResponse
U
TlsExtension
U
WebSocketHandler
U
WebSocketScope
U
WsAccept
U
WsMessage
U
WsSend
U
WsTestSession
U
ZeroCopySend
V
compose
V
double_to_single_callable
V
guarantee_single_callable
V
headers_from_wire
V
headers_to_wire
V
latin1_decode
V
latin1_encode
V
percent_decode
V
run_conformance
V
run_http
V
run_http_app
V
run_http_scoped
V
run_http_scoped_drain
V
run_http_stream
V
run_legacy
V
run_lifespan
V
to_asgi
V
validate_events
V
validate_http_response
V
validate_inbound
V
validate_lifespan_replies
V
validate_ws_response
V
ws_run
V
ws_run_app

moonbitstack/moonasgi/ws does not have a README file

WebSocketHandler

pub(all) struct WebSocketHandler {
  on_connect : (@moonbitstack/moonasgi/spec.WebSocketScope
WebSocketScope) -> WsAccept
  on_receive : (WsMessage) -> Array[WsSend]
  on_disconnect : (Int, String?) -> Array[WsSend]
}

A synchronous WebSocket application in the connect / receive / disconnect shape, the WebSocket analog of the http Handler. on_connect decides the handshake from the scope; on_receive maps each inbound WsMessage to the frames to send back (it may Close); on_disconnect runs when the client goes away, carrying the close code and the optional close reason (ASGI 2.5). Driven in-process by ws_run and the TestClient, so accept/subprotocol/echo/close logic is testable on every backend without an async socket — the faithful synchronous core the async server (mooncat) lifts onto AsgiApp.

WebSocketHandler::echo

source

fn WebSocketHandler::echo(subprotocol? : String) -> WebSocketHandler

An echo handler: accept the handshake (optionally negotiating subprotocol), then send every received message straight back — text as text, binary as binary. The canonical WebSocket smoke test.

WebSocketHandler::new

source

fn WebSocketHandler::new(on_connect? : (@moonbitstack/moonasgi/spec.WebSocketScope
WebSocketScope) -> WsAccept, on_receive? : (WsMessage) -> Array[WsSend], on_disconnect? : (Int, String?) -> Array[WsSend]) -> WebSocketHandler

Build a WebSocketHandler. on_connect defaults to accepting the handshake with no chosen subprotocol and no extra headers; on_receive and on_disconnect default to doing nothing. Callers override only the phases they care about.

WsAccept

source

pub(all) enum WsAccept {
  Accept(subprotocol~ : String?, headers~ : Array[(String, String)])
  Reject(code~ : Int, reason~ : String)
  DenyHttp(status~ : Int, headers~ : Array[(String, String)], body~ : Bytes)
} derive(Eq)

The application's answer to a WebSocketConnect, mirroring the three replies ASGI allows to an opening handshake: Accept it (optionally choosing a subprotocol and adding response headers), Reject it with a bare close code (ASGI closes the handshake with websocket.close), or DenyHttp it with a full HTTP response (the websocket.http.response extension — a real status

headers + body instead of a bare close).

WsAccept::equal

source

fn WsAccept::equal(WsAccept, WsAccept) -> Bool

WsAccept::not_equal

source

fn WsAccept::not_equal(x : WsAccept, y : WsAccept) -> Bool

WsMessage

source

pub(all) enum WsMessage {
  Text(String)
  Binary(Bytes)
} derive(Eq)

A message crossing a WebSocket in either direction: a UTF-8 Text frame or a Binary frame. The ergonomic form of WebSocketReceive / WebSocketSendText / WebSocketSendBytes, so a WebSocketHandler reasons over messages instead of raw events.

WsMessage::equal

source

fn WsMessage::equal(WsMessage, WsMessage) -> Bool

WsMessage::not_equal

source

fn WsMessage::not_equal(x : WsMessage, y : WsMessage) -> Bool

WsSend

source

pub(all) enum WsSend {
  SendText(String)
  SendBinary(Bytes)
  Close(code~ : Int, reason~ : String)
} derive(Eq)

An outbound action a WebSocketHandler takes while the connection is open: send a SendText / SendBinary frame, or Close the connection with a code and reason. A Close ends the handler's send stream — the driver stops pulling further inbound messages, mirroring a server that has closed the socket.

WsSend::equal

source

fn WsSend::equal(WsSend, WsSend) -> Bool

WsSend::not_equal

source

fn WsSend::not_equal(x : WsSend, y : WsSend) -> Bool

ws_run

source

fn ws_run(handler : WebSocketHandler, scope : @moonbitstack/moonasgi/spec.Scope
Scope, inbound : Array[@moonbitstack/moonasgi/spec.Event
Event]) -> Array[@moonbitstack/moonasgi/spec.Event
Event]

Drive a WebSocketHandler over an inbound event sequence, returning the outbound events a server would send. The WebSocket counterpart of run_http: a WebSocket scope is driven through drive_ws; any other scope yields [], since this sugar covers websocket connections only.

ws_run_app

source

fn ws_run_app(app : (@moonbitstack/moonasgi/spec.WebSocketScope
WebSocketScope, Array[@moonbitstack/moonasgi/spec.Event
Event]) -> Array[@moonbitstack/moonasgi/spec.Event
Event], scope : @moonbitstack/moonasgi/spec.Scope
Scope, inbound : Array[@moonbitstack/moonasgi/spec.Event
Event]) -> Array[@moonbitstack/moonasgi/spec.Event
Event]

The general sans-transport WebSocket core: hand the whole inbound event stream and the @spec.WebSocketScope to app and return the outbound events it emits. The escape hatch under ws_run for applications whose control flow is not the connect/receive/disconnect fold — an app is free to inspect every scope field (subprotocols, headers, extensions, state) and emit any sequence. Non-websocket scopes yield []. The WebSocket analog of run_http_app.