zero4rs 2.0.0

zero4rs is a powerful, pragmatic, and extremely fast web framework for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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
50
51
52
53
54
55
56
57
58
59
60
61

use actix_web::{rt, web, Error, HttpRequest, HttpResponse, Responder};
use tokio::sync::broadcast;

use crate::core::{request2::Render, R};

/// Handshake and start basic WebSocket handler.
///
/// This example is just for demonstration of simplicity. In reality, you likely want to include
/// some handling of heartbeats for connection health tracking to free up server resources when
/// connections die or network issues arise.
pub async fn basic_ws(req: HttpRequest, stream: web::Payload) -> Result<HttpResponse, Error> {
    let (res, session, msg_stream) = actix_ws::handle(&req, stream)?;

    // spawn websocket handler (and don't await it) so that the response is returned immediately
    rt::spawn(super::echo_basic_ws(session, msg_stream));

    Ok(res)
}

/// Handshake and start WebSocket handler with heartbeats.
pub async fn heartbeat_ws(req: HttpRequest, stream: web::Payload) -> Result<HttpResponse, Error> {
    let (res, session, msg_stream) = actix_ws::handle(&req, stream)?;

    // spawn websocket handler (and don't await it) so that the response is returned immediately
    rt::spawn(super::echo_heartbeat_ws(session, msg_stream));

    Ok(res)
}

/// Handshake and start broadcast WebSocket handler with heartbeats.
pub async fn broadcast_ws(
    req: HttpRequest,
    stream: web::Payload,
    tx: web::Data<broadcast::Sender<web::Bytes>>,
) -> Result<HttpResponse, Error> {
    let (res, session, msg_stream) = actix_ws::handle(&req, stream)?;

    // spawn websocket handler (and don't await it) so that the response is returned immediately
    rt::spawn(super::echo_broadcast_ws(
        session,
        msg_stream,
        tx.subscribe(),
    ));

    Ok(res)
}

/// Send message to clients connected to broadcast WebSocket.
pub async fn send_to_broadcast_ws(
    request: HttpRequest,
    body: web::Bytes,
    tx: web::Data<broadcast::Sender<web::Bytes>>,
) -> Result<impl Responder, Error> {
    tx.send(body).map_err(|e| {
        log::error!("send_to_broadcast_ws: error={:?}", e);
        actix_web::error::ErrorInternalServerError(e)
    })?;

    // Ok(HttpResponse::NoContent())
    Ok(request.json(200, R::ok(true)))
}