Skip to main content

infinity_daemon/
ws_handler.rs

1use bytes::Bytes;
2use futures_util::{SinkExt, StreamExt};
3use http_body_util::Full;
4use hyper::body::Incoming;
5use hyper::server::conn::http1;
6use hyper::{Request, Response, StatusCode};
7use hyper_util::rt::TokioIo;
8use infinity_protocol::ClientMessage;
9use tokio::net::TcpStream;
10use tokio::sync::mpsc;
11use tokio_tungstenite::WebSocketStream;
12use tokio_tungstenite::tungstenite::Message;
13use tokio_tungstenite::tungstenite::protocol::Role;
14
15use crate::client_handler::handle_client_channels;
16use crate::session::SharedSessionManager;
17use crate::web_assets;
18
19/// Accept loop serving HTTP/WebSocket clients on a pre-bound listener.
20/// Connections are handled via `spawn_local`, so this must run inside a
21/// `LocalSet`. Used by both the daemon and in-process integration tests
22/// (which bind an OS-assigned port).
23pub async fn serve(listener: tokio::net::TcpListener, session_manager: SharedSessionManager) {
24    loop {
25        match listener.accept().await {
26            Ok((stream, _)) => {
27                let mgr = session_manager.clone();
28                tokio::task::spawn_local(rap_protocol::log_panic(
29                    "http_client_handler",
30                    handle_http_client(stream, mgr),
31                ));
32            }
33            Err(e) => {
34                tracing::warn!("ws accept error: {e}");
35            }
36        }
37    }
38}
39
40/// Handle a TCP connection that may be an HTTP request or a WebSocket upgrade.
41pub async fn handle_http_client(stream: TcpStream, session_manager: SharedSessionManager) {
42    let io = TokioIo::new(stream);
43    let mgr = session_manager.clone();
44
45    let service = hyper::service::service_fn(move |req: Request<Incoming>| {
46        let mgr = mgr.clone();
47        async move { handle_request(req, mgr) }
48    });
49
50    if let Err(e) = http1::Builder::new()
51        .serve_connection(io, service)
52        .with_upgrades()
53        .await
54    {
55        tracing::debug!("http connection error: {e}");
56    }
57}
58
59fn handle_request(
60    req: Request<Incoming>,
61    session_manager: SharedSessionManager,
62) -> Result<Response<Full<Bytes>>, hyper::Error> {
63    // Check for WebSocket upgrade
64    let is_upgrade = req
65        .headers()
66        .get(hyper::header::UPGRADE)
67        .and_then(|v| v.to_str().ok())
68        .is_some_and(|v| v.eq_ignore_ascii_case("websocket"));
69
70    if is_upgrade {
71        let key = req
72            .headers()
73            .get("Sec-WebSocket-Key")
74            .expect("bug: missing Sec-WebSocket-Key on upgrade request")
75            .clone();
76        let accept = tokio_tungstenite::tungstenite::handshake::derive_accept_key(key.as_bytes());
77        let response = Response::builder()
78            .status(StatusCode::SWITCHING_PROTOCOLS)
79            .header(hyper::header::UPGRADE, "websocket")
80            .header(hyper::header::CONNECTION, "Upgrade")
81            .header("Sec-WebSocket-Accept", accept)
82            .body(Full::new(Bytes::new()))
83            .expect("bug: failed to build upgrade response");
84
85        tokio::task::spawn_local(async move {
86            match hyper::upgrade::on(req).await {
87                Ok(upgraded) => {
88                    let ws = WebSocketStream::from_raw_socket(
89                        TokioIo::new(upgraded),
90                        Role::Server,
91                        None,
92                    )
93                    .await;
94                    run_ws_loop(ws, session_manager).await;
95                }
96                Err(e) => tracing::warn!("websocket upgrade failed: {e}"),
97            }
98        });
99
100        return Ok(response);
101    }
102
103    // Serve static files
104    let path = req.uri().path();
105    if let Some((content_type, body)) = web_assets::serve_static(path) {
106        return Ok(Response::builder()
107            .status(StatusCode::OK)
108            .header(hyper::header::CONTENT_TYPE, content_type)
109            .body(Full::new(Bytes::from_static(body)))
110            .expect("bug: failed to build static response"));
111    }
112
113    // SPA fallback: serve index.html for non-asset paths
114    if !path.contains('.')
115        && let Some((content_type, body)) = web_assets::serve_static("/")
116    {
117        return Ok(Response::builder()
118            .status(StatusCode::OK)
119            .header(hyper::header::CONTENT_TYPE, content_type)
120            .body(Full::new(Bytes::from_static(body)))
121            .expect("bug: failed to build fallback response"));
122    }
123
124    Ok(Response::builder()
125        .status(StatusCode::NOT_FOUND)
126        .body(Full::new(Bytes::from_static(b"not found")))
127        .expect("bug: failed to build 404 response"))
128}
129
130/// WebSocket message loop, shared between upgrade-based and direct connections.
131async fn run_ws_loop<S>(ws_stream: WebSocketStream<S>, session_manager: SharedSessionManager)
132where
133    S: tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin,
134{
135    let (mut ws_tx, mut ws_rx) = ws_stream.split();
136    let (client_msg_tx, client_msg_rx) = mpsc::unbounded_channel();
137    let (daemon_msg_tx, mut daemon_msg_rx) = mpsc::unbounded_channel();
138
139    let mgr = session_manager.clone();
140    tokio::pin! {
141        let handler = handle_client_channels(client_msg_rx, daemon_msg_tx, mgr);
142    }
143
144    loop {
145        tokio::select! {
146            msg = daemon_msg_rx.recv() => {
147                let Some(msg) = msg else { break };
148                let json = serde_json::to_string(&msg).expect("bug: failed to serialize DaemonMessage");
149                if ws_tx.send(Message::Text(json.into())).await.is_err() { break; }
150            }
151            _ = &mut handler => {
152                return;
153            }
154            frame = ws_rx.next() => {
155                match frame {
156                    Some(Ok(Message::Text(text))) => {
157                        let Ok(msg) = serde_json::from_str::<ClientMessage>(&text) else { continue };
158                        let _ = client_msg_tx.send(msg);
159                    }
160                    Some(Ok(Message::Close(_))) | None => break,
161                    _ => continue,
162                }
163            }
164        }
165    }
166
167    drop(client_msg_tx);
168    handler.await;
169}