Function warp::filters::ws::ws

source · []
pub fn ws() -> impl Filter<Extract = (Ws,), Error = Rejection> + Copy
Expand description

Creates a Websocket Filter.

The yielded Ws is used to finish the websocket upgrade.

Note

This filter combines multiple filters internally, so you don’t need them:

  • Method must be GET
  • Header connection must be upgrade
  • Header upgrade must be websocket
  • Header sec-websocket-version must be 13
  • Header sec-websocket-key must be set.

If the filters are met, yields a Ws. Calling Ws::on_upgrade will return a reply with:

  • Status of 101 Switching Protocols
  • Header connection: upgrade
  • Header upgrade: websocket
  • Header sec-websocket-accept with the hash value of the received key.
Examples found in repository?
examples/websockets.rs (line 12)
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
async fn main() {
    pretty_env_logger::init();

    let routes = warp::path("echo")
        // The `ws()` filter will prepare the Websocket handshake.
        .and(warp::ws())
        .map(|ws: warp::ws::Ws| {
            // And then our closure will be called when it completes...
            ws.on_upgrade(|websocket| {
                // Just echo all messages back...
                let (tx, rx) = websocket.split();
                rx.forward(tx).map(|result| {
                    if let Err(e) = result {
                        eprintln!("websocket error: {:?}", e);
                    }
                })
            })
        });

    warp::serve(routes).run(([127, 0, 0, 1], 3030)).await;
}
More examples
Hide additional examples
examples/websockets_chat.rs (line 36)
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
async fn main() {
    pretty_env_logger::init();

    // Keep track of all connected users, key is usize, value
    // is a websocket sender.
    let users = Users::default();
    // Turn our "state" into a new Filter...
    let users = warp::any().map(move || users.clone());

    // GET /chat -> websocket upgrade
    let chat = warp::path("chat")
        // The `ws()` filter will prepare Websocket handshake...
        .and(warp::ws())
        .and(users)
        .map(|ws: warp::ws::Ws, users| {
            // This will call our function if the handshake succeeds.
            ws.on_upgrade(move |socket| user_connected(socket, users))
        });

    // GET / -> index html
    let index = warp::path::end().map(|| warp::reply::html(INDEX_HTML));

    let routes = index.or(chat);

    warp::serve(routes).run(([127, 0, 0, 1], 3030)).await;
}