Struct worker::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 async fn connect_with_protocols( url: Url, protocols: Option<Vec<&str>> ) -> Result<WebSocket>

Attempts to establish a WebSocket connection to the provided Url and protocol.

Example:

let ws = WebSocket::connect_with_protocols("wss://echo.zeb.workers.dev/".parse()?, Some(vec!["GiggleBytes"])).await?;

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.

pub fn serialize_attachment<T: Serialize>(&self, value: T) -> Result<()>

pub fn deserialize_attachment<T: DeserializeOwned>(&self) -> Result<Option<T>>

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 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 Send for WebSocket

impl StructuralPartialEq for WebSocket

impl Sync for WebSocket