Struct roa::websocket::Websocket

pub struct Websocket<F, S, Fut> where
    F: Fn(Context<S>, SocketStream) -> Fut,  { /* fields omitted */ }

This is supported on feature="websocket" only.

The Websocket middleware.

Example

use futures::StreamExt;
use roa::router::{Router, RouterError};
use roa::websocket::Websocket;
use roa::{App, Context};
use roa::http::Method;

let router = Router::new().on("/chat", Websocket::new(|_ctx, stream| async move {
    let (write, read) = stream.split();
    // echo
    if let Err(err) = read.forward(write).await {
        println!("forward err: {}", err);
    }
}));
let app = App::new().end(router.routes("/")?);
Ok(())

Parameter

• Context

The context is the same with roa context, however, neither read body from request or write anything to response is unavailing.

• SocketStream

The websocket stream, implementing Stream and Sink.

Return

Must be (), as roa cannot deal with errors occurring in websocket.

Methods

impl<F, S, Fut> Websocket<F, S, Fut> where
    F: Fn(Context<S>, SocketStream) -> Fut, 

pub fn new(task: F) -> Self

This is supported on feature="websocket" only.

Construct a websocket middleware by task closure.

pub fn with_config(config: WebSocketConfig, task: F) -> Self

This is supported on feature="websocket" only.

Construct a websocket middleware with config.

Example

use futures::StreamExt;
use roa::router::{Router, RouterError};
use roa::websocket::{Websocket, WebSocketConfig};
use roa::{App, Context};
use roa::http::Method;

let router = Router::new().on("/chat", Websocket::with_config(
    WebSocketConfig::default(),
    |_ctx, stream| async move {
        let (write, read) = stream.split();
        // echo
        if let Err(err) = read.forward(write).await {
            println!("forward err: {}", err);
        }
    })
);
let app = App::new().end(router.routes("/")?);

Trait Implementations

impl<'a, F, S, Fut> Endpoint<'a, S> for Websocket<F, S, Fut> where
    S: State,
    F: 'static + Sync + Send + Fn(Context<S>, SocketStream) -> Fut,
    Fut: 'static + Send + Future<Output = ()>, 

fn call<'async_trait>(
    &'a self,
    ctx: &'a mut Context<S>
) -> Pin<Box<dyn Future<Output = Result<(), Status>> + 'async_trait>> where
    'a: 'async_trait,
    Self: 'async_trait, 

Call this endpoint.

impl<F, S, Fut> Send for Websocket<F, S, Fut> where
    F: Sync + Send + Fn(Context<S>, SocketStream) -> Fut, 

impl<F, S, Fut> Sync for Websocket<F, S, Fut> where
    F: Sync + Send + Fn(Context<S>, SocketStream) -> Fut,