Struct Websocket 

pub struct Websocket<InputEncoding, OutputEncoding>(/* private fields */);

The websocket protocol that encodes the input and output streams using a websocket connection.

The websocket protocol accepts two generic argument that define the input and output serialization formats. For example, Websocket<CborEncoding, JsonEncoding> would accept a stream of Cbor-encoded messages and return a stream of JSON-encoded messages.

Example

use server_fn::{ServerFnError, BoxedStream, Websocket, codec::JsonEncoding};
use serde::{Serialize, Deserialize};

#[derive(Clone, Serialize, Deserialize)]
pub struct Message {
    user: String,
    message: String,
}
// The websocket protocol can be used on any server function that accepts and returns a [`BoxedStream`]
// with items that can be encoded by the input and output encoding generics.
//
// In this case, the input and output encodings are [`Json`] and [`Json`], respectively which requires
// the items to implement [`Serialize`] and [`Deserialize`].
#[server(protocol = Websocket<JsonEncoding, JsonEncoding>)]
async fn echo_websocket(
    input: BoxedStream<Message, ServerFnError>,
) -> Result<BoxedStream<Message, ServerFnError>, ServerFnError> {
    Ok(input.into())
}

Trait Implementations

impl<Input, InputItem, OutputItem, InputEncoding, OutputEncoding, Client, Server, Error, InputStreamError, OutputStreamError> Protocol<Input, BoxedStream<OutputItem, OutputStreamError>, Client, Server, Error, InputStreamError, OutputStreamError> for Websocket<InputEncoding, OutputEncoding>

where Input: Deref<Target = BoxedStream<InputItem, InputStreamError>> + Into<BoxedStream<InputItem, InputStreamError>> + From<BoxedStream<InputItem, InputStreamError>>, InputEncoding: Encodes<InputItem> + Decodes<InputItem>, OutputEncoding: Encodes<OutputItem> + Decodes<OutputItem>, InputStreamError: FromServerFnError + Send, OutputStreamError: FromServerFnError + Send, Error: FromServerFnError + Send, Server: Server<Error, InputStreamError, OutputStreamError>, Client: Client<Error, InputStreamError, OutputStreamError>, OutputItem: Send + 'static, InputItem: Send + 'static,

const METHOD: Method = Method::GET

The HTTP method used for requests.

async fn run_server<F, Fut>( request: Server::Request, server_fn: F, ) -> Result<Server::Response, Error>

where F: Fn(Input) -> Fut + Send, Fut: Future<Output = Result<BoxedStream<OutputItem, OutputStreamError>, Error>> + Send,

Run the server function on the server. The implementation should handle deserializing the input, running the server function, and serializing the output.

fn run_client( path: &str, input: Input, ) -> impl Future<Output = Result<BoxedStream<OutputItem, OutputStreamError>, Error>> + Send

Run the server function on the client. The implementation should handle serializing the input, sending the request, and deserializing the output.