Struct worker_plus::WebSocket

pub struct WebSocket { /* private fields */ }

Wrapper struct for underlying worker-sys WebSocket

Implementations

impl WebSocket

pub async fn connect(url: Url) -> Result<WebSocket>

Attempts to establish a WebSocket connection to the provided Url.

Example:

let ws = WebSocket::connect("wss://echo.zeb.workers.dev/".parse()?).await?;

// It's important that we call this before we send our first message, otherwise we will
// not have any event listeners on the socket to receive the echoed message.
let mut event_stream = ws.events()?;

ws.accept()?;
ws.send_with_str("Hello, world!")?;

while let Some(event) = event_stream.next().await {
    let event = event?;

    if let WebsocketEvent::Message(msg) = event {
        if let Some(text) = msg.text() {
            return Response::ok(text);
        }
    }
}

Response::error("never got a message echoed back :(", 500)

pub fn accept(&self) -> Result<()>

Accepts the connection, allowing for messages to be sent to and from the WebSocket.

pub fn send<T: Serialize>(&self, data: &T) -> Result<()>

Serialize data into a string using serde and send it through the WebSocket

pub fn send_with_str<S: AsRef<str>>(&self, data: S) -> Result<()>

Sends a raw string through the WebSocket

pub fn send_with_bytes<D: AsRef<[u8]>>(&self, bytes: D) -> Result<()>

Sends raw binary data through the WebSocket.

pub fn close<S: AsRef<str>>(
    &self,
    code: Option<u16>,
    reason: Option<S>
) -> Result<()>

Closes this channel. This method translates to three different underlying method calls based of the parameters passed.

If the following parameters are Some:

• code and reason -> close_with_code_and_reason
• code -> close_with_code
• reason or none -> close

Effectively, if only reason is Some, the reason argument will be ignored.

pub fn events(&self) -> Result<EventStream<'_>>

Gets an implementation Stream that yields events from the inner WebSocket.

Trait Implementations

impl AsRef<WebSocket> for WebSocket

fn as_ref(&self) -> &WebSocket

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for WebSocket

fn clone(&self) -> WebSocket

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for WebSocket

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

Formats the value using the given formatter.

impl From<WebSocket> for WebSocket

fn from(socket: WebSocket) -> Self

Converts to this type from the input type.

impl PartialEq<WebSocket> for WebSocket

fn eq(&self, other: &WebSocket) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for WebSocket

impl StructuralEq for WebSocket

impl StructuralPartialEq for WebSocket