infinity_daemon/
ws_handler.rs1use 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
19pub 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
40pub 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 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 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 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
130async 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}