Struct fluvio_ws_stream_wasm::WsMeta

pub struct WsMeta { /* fields omitted */ }

The meta data related to a websocket. Allows access to the methods on the WebSocket API. This is split from the Stream/Sink so you can pass the latter to a combinator whilst continuing to use this API.

A WsMeta instance is observable through the pharos::Observable trait. The type of event is WsEvent. In the case of a Close event, there will be additional information included as a CloseEvent.

When you drop this, the connection does not get closed, however when you drop WsStream it does.

Most of the methods on this type directly map to the web API. For more documentation, check the MDN WebSocket documentation.

Implementations

impl WsMeta

pub async fn connect(
    url: impl AsRef<str>,
    protocols: impl Into<Option<Vec<&str>>>
) -> Result<(Self, WsStream), WsErr>

Connect to the server. The future will resolve when the connection has been established with a successful WebSocket handshake.

This returns both a WsMeta (allow manipulating and requesting meta data for the connection) and a WsStream (Stream/Sink over WsMessage). WsStream can be wrapped to obtain AsyncRead/AsyncWrite/AsyncBufRead with WsStream::into_io.

Errors

Browsers will forbid making websocket connections to certain ports. See this Stack Overflow question. connect will return a [WsErr::ForbiddenPort].

If the URL is invalid, a WsErr::InvalidUrl is returned. See the HTML Living Standard for more information.

When the connection fails (server port not open, wrong ip, wss:// on ws:// server, … See the HTML Living Standard for details on all failure possibilities), a WsErr::ConnectionFailed is returned.

Note: Sending protocols to a server that doesn’t support them will make the connection fail.

pub async fn close(&self) -> Result<CloseEvent, WsErr>

Close the socket. The future will resolve once the socket’s state has become WsState::CLOSED. See: MDN Documentation

pub async fn close_code(&self, code: u16) -> Result<CloseEvent, WsErr>

Close the socket. The future will resolve once the socket’s state has become WsState::CLOSED. See: MDN Documentation

pub async fn close_reason(
    &self,
    code: u16,
    reason: impl AsRef<str>
) -> Result<CloseEvent, WsErr>

Close the socket. The future will resolve once the socket’s state has become WsState::CLOSED. See: MDN Documentation

pub fn ready_state(&self) -> WsState

Verify the WsState of the connection.

pub fn wrapped(&self) -> &WebSocket

Access the wrapped web_sys::WebSocket directly.

ws_stream_wasm tries to expose all useful functionality through an idiomatic rust API, so hopefully you won’t need this, however if I missed something, you can.

Caveats

If you call set_onopen, set_onerror, set_onmessage or set_onclose on this, you will overwrite the event listeners from ws_stream_wasm, and things will break.

pub fn buffered_amount(&self) -> u32

The number of bytes of data that have been queued but not yet transmitted to the network.

NOTE: that this is the number of bytes buffered by the underlying platform WebSocket implementation. It does not reflect any buffering performed by ws_stream_wasm.

pub fn extensions(&self) -> String

The extensions selected by the server as negotiated during the connection.

NOTE: This is an untested feature. The back-end server we use for testing (tungstenite) does not support Extensions.

pub fn protocol(&self) -> String

The name of the sub-protocol the server selected during the connection.

This will be one of the strings specified in the protocols parameter when creating this WsMeta instance.

pub fn url(&self) -> String

Retrieve the address to which this socket is connected.

Trait Implementations

impl Debug for WsMeta

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Observable<WsEvent> for WsMeta

type Error = PharErr

The error type that is returned if observing is not possible.

fn observe(
    &mut self,
    options: ObserveConfig<WsEvent>
) -> Observe<'_, WsEvent, Self::Error>

Add an observer to the observable. Options allow chosing the channel type and to filter events with a predicate.