Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 2 additions & 0 deletions crates/uhttp/Cargo.toml
Original file line number Diff line number Diff line change
Expand Up @@ -27,6 +27,8 @@ tokio = { workspace = true, features = [
"fs",
"net",
"macros",
"sync",
"time",
] }
tokio-util = { workspace = true, features = ["io", "io-util", "futures-util"] }

Expand Down
10 changes: 8 additions & 2 deletions crates/uhttp/README.md
Original file line number Diff line number Diff line change
Expand Up @@ -273,16 +273,22 @@ use uhttp::websocket::Websocket;
async fn main() -> anyhow::Result<()> {
Server::builder()
.handler(|req, res| async move {
Websocket::upgrade(req, res, |mut socket| async move {
Websocket::upgrade(req, res, |socket_sender, mut socket_receiver| async move {
tokio::task::spawn(async move {
loop {
if socket.send("Hello").await.is_err() {
if socket_sender.send_raw("Hello").await.is_err() {
break;
};
tokio::time::sleep(Duration::from_millis(1000)).await;
}
});

tokio::task::spawn(async move {
while let Ok(Some(msg)) = socket_receiver.recv_raw().await {
println!("GOT: {:?}", msg);
}
});

Ok(())
})
})
Expand Down
1 change: 1 addition & 0 deletions crates/uhttp/src/lib.rs
Original file line number Diff line number Diff line change
Expand Up @@ -18,6 +18,7 @@ mod types;
#[cfg(feature = "websocket")]
mod websocket;

pub use http::Method;
pub use http::StatusCode;
pub use tokio_util::sync::CancellationToken;

Expand Down
29 changes: 26 additions & 3 deletions crates/uhttp/src/request.rs
Original file line number Diff line number Diff line change
@@ -1,3 +1,4 @@
#[cfg(feature = "router")]
use std::collections::HashMap;
use std::pin::Pin;

Expand Down Expand Up @@ -34,7 +35,18 @@ pub struct Request {

pub body: Pin<Box<dyn AsyncRead + Send>>,

#[cfg(feature = "router")]
pub params: HashMap<String, String>,

/// The route *pattern* this request matched, e.g. `/users/:id` — never the
/// concrete path.
///
/// Populated by the router after matching. Telemetry should label spans and
/// metrics with this rather than `uri.path()`, since the concrete path embeds
/// ids and would create unbounded cardinality. `None` means nothing matched
/// (the 404 path).
#[cfg(feature = "router")]
pub route: Option<String>,
}

impl Default for Request {
Expand All @@ -46,7 +58,10 @@ impl Default for Request {
headers: Default::default(),
extensions: Default::default(),
body: Box::pin(tokio::io::empty()),
#[cfg(feature = "router")]
params: Default::default(),
#[cfg(feature = "router")]
route: None,
}
}
}
Expand All @@ -56,15 +71,19 @@ impl std::fmt::Debug for Request {
&self,
f: &mut std::fmt::Formatter<'_>,
) -> std::fmt::Result {
f.debug_struct("Request")
let mut debug = f.debug_struct("Request");
debug
.field("method", &self.method)
.field("uri", &self.uri)
.field("version", &self.version)
.field("headers", &self.headers)
.field("extensions", &self.extensions)
.field("body", &"<body>".to_string())
.field("body", &"<body>".to_string());
#[cfg(feature = "router")]
debug
.field("params", &self.params)
.finish()
.field("route", &self.route);
debug.finish()
}
}

Expand All @@ -85,8 +104,12 @@ impl Request {
version: parts.version,
headers: parts.headers,
extensions: parts.extensions,
#[cfg(feature = "router")]
params: HashMap::new(),
body: Box::pin(body),
// Set by the router once a route matches; see the field docs.
#[cfg(feature = "router")]
route: None,
}
}

Expand Down
19 changes: 19 additions & 0 deletions crates/uhttp/src/response.rs
Original file line number Diff line number Diff line change
Expand Up @@ -6,6 +6,8 @@ use http::HeaderName;
use http::HeaderValue;
use http::StatusCode;
use http::Version;
#[cfg(feature = "json")]
use serde::Serialize;

use super::types::HyperResponseBuilder;
use crate::ResponseBody;
Expand Down Expand Up @@ -92,4 +94,21 @@ impl Response {
};
Ok(response?)
}

/// Build a response with an empty body.
pub fn empty(self) -> crate::Result<super::types::HyperInfallibleResponse> {
self.body(vec![])
}

/// Build a JSON response, setting the `Content-Type` header to
/// `application/json`.
#[cfg(feature = "json")]
pub fn json(
self,
json: impl Serialize,
) -> crate::Result<super::types::HyperInfallibleResponse> {
self
.header("Content-Type", "application/json")
.body(serde_json::to_vec(&json)?)
}
}
5 changes: 5 additions & 0 deletions crates/uhttp/src/router.rs
Original file line number Diff line number Diff line change
Expand Up @@ -296,6 +296,11 @@ impl<T: Clone + Send + Sync + 'static> Router<T> {
.await;
};

// `pattern()` gives the route as registered (with `:param`
// placeholders) rather than the concrete path, which is what keeps
// telemetry cardinality bounded.
req.route = Some(params.pattern());

for (key, value) in params.params() {
req.params.insert(
key.to_string(),
Expand Down
110 changes: 99 additions & 11 deletions crates/uhttp/src/websocket.rs
Original file line number Diff line number Diff line change
@@ -1,4 +1,7 @@
use std::future::Future;
use std::sync::Arc;
use std::sync::Weak;
use std::time::Duration;

use anyhow::anyhow;
use futures::SinkExt;
Expand All @@ -9,13 +12,24 @@ use http::header;
use hyper::upgrade::OnUpgrade;
use hyper::upgrade::Upgraded;
use hyper_util::rt::TokioIo;
#[cfg(feature = "json")]
use serde::Serialize;
#[cfg(feature = "json")]
use serde::de::DeserializeOwned;
use tokio::sync::Mutex;
use tokio_tungstenite::WebSocketStream;
pub use tokio_tungstenite::tungstenite::Message;
use tokio_tungstenite::tungstenite::handshake::derive_accept_key;
pub use tokio_tungstenite::tungstenite::protocol::CloseFrame;
use tokio_tungstenite::tungstenite::protocol::Role;

type WebsocketIo = WebSocketStream<TokioIo<Upgraded>>;
type WebsocketSink = SplitSink<WebsocketIo, Message>;

/// How often to ping the peer. Browsers cannot send pings themselves, so the
/// server has to keep the connection warm or intermediate proxies (which
/// commonly idle out at 60s) will drop it.
const PING_INTERVAL: Duration = Duration::from_secs(30);

pub struct Websocket {
stream: WebsocketIo,
Expand All @@ -28,7 +42,7 @@ impl Websocket {
callback: F,
) -> crate::Result<crate::HandlerResponse>
where
F: 'static + Send + FnOnce(Websocket) -> Fut,
F: 'static + Send + FnOnce(WebsocketSender, WebsocketReceiver) -> Fut,
Fut: 'static + Send + Future<Output = crate::Result<()>>,
{
let version = req.headers.get(header::SEC_WEBSOCKET_VERSION);
Expand Down Expand Up @@ -57,7 +71,11 @@ impl Websocket {
let stream =
WebSocketStream::from_raw_socket(TokioIo::new(upgraded), Role::Server, None).await;

callback(Websocket { stream }).await.ok();
let (sender, receiver) = Websocket { stream }.split();

tokio::spawn(keepalive(Arc::downgrade(&sender.0)));

let _ = callback(sender, receiver).await;
});

res
Expand Down Expand Up @@ -93,42 +111,112 @@ impl Websocket {

pub fn split(self) -> (WebsocketSender, WebsocketReceiver) {
let (sender, receiver) = self.stream.split();
(WebsocketSender(sender), WebsocketReceiver(receiver))
(
WebsocketSender(Arc::new(Mutex::new(sender))),
WebsocketReceiver(receiver),
)
}

pub fn reunite(
sender: WebsocketSender,
receiver: WebsocketReceiver,
) -> crate::Result<Self> {
let stream = sender.0.reunite(receiver.0)?;
let sender = Arc::try_unwrap(sender.0)
.map_err(|_| anyhow!("websocket sender is still cloned elsewhere"))?
.into_inner();

let stream = sender.reunite(receiver.0)?;
Ok(Self { stream })
}
}

pub struct WebsocketSender(SplitSink<WebsocketIo, Message>);
/// Pings the peer on an interval until the socket errors or every
/// [`WebsocketSender`] has been dropped. Holds a [`Weak`] so it neither keeps the
/// socket alive on its own nor blocks [`Websocket::reunite`].
async fn keepalive(sink: Weak<Mutex<WebsocketSink>>) {
let mut interval = tokio::time::interval(PING_INTERVAL);
interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
interval.tick().await;

loop {
interval.tick().await;

let Some(sink) = sink.upgrade() else {
return;
};

if sink
.lock()
.await
.send(Message::Ping(Default::default()))
.await
.is_err()
{
return;
}
}
}

/// A cloneable handle for sending messages on a websocket.
///
/// Cloning is cheap and every clone shares the same underlying sink, so the
/// connection can be driven from several tasks at once (e.g. one task relaying
/// messages received from a broadcast channel while another handles pongs).
#[derive(Clone)]
pub struct WebsocketSender(Arc<Mutex<WebsocketSink>>);

impl WebsocketSender {
pub async fn send(
&mut self,
/// Serialize `message` as JSON and send it as a text frame.
#[cfg(feature = "json")]
pub async fn send<S: Serialize>(
&self,
message: S,
) -> crate::Result<()> {
let json = serde_json::to_string(&message)?;
self.send_raw(Message::text(json)).await
}

/// Send a raw websocket message.
pub async fn send_raw(
&self,
message: impl Into<Message>,
) -> crate::Result<()> {
self.0.send(message.into()).await?;
self.0.lock().await.send(message.into()).await?;
Ok(())
}

pub async fn close(
&mut self,
&self,
frame: Option<CloseFrame>,
) -> crate::Result<()> {
self.0.send(Message::Close(frame)).await?;
self.0.lock().await.send(Message::Close(frame)).await?;
Ok(())
}
}

pub struct WebsocketReceiver(SplitStream<WebsocketIo>);

impl WebsocketReceiver {
pub async fn recv(&mut self) -> crate::Result<Option<Message>> {
/// Receive the next message, deserializing JSON text/binary frames.
///
/// Ping, Pong and Frame messages are skipped. A close frame (or the socket
/// ending) yields `Ok(None)`.
#[cfg(feature = "json")]
pub async fn recv<D: DeserializeOwned>(&mut self) -> crate::Result<Option<D>> {
while let Some(message) = self.0.next().await {
let payload = match message? {
Message::Text(text) => serde_json::from_str(&text)?,
Message::Binary(bytes) => serde_json::from_slice(&bytes)?,
Message::Close(_) => return Ok(None),
Message::Ping(_) | Message::Pong(_) | Message::Frame(_) => continue,
};
return Ok(Some(payload));
}
Ok(None)
}

/// Receive the next raw websocket message.
pub async fn recv_raw(&mut self) -> crate::Result<Option<Message>> {
match self.0.next().await {
Some(message) => Ok(Some(message?)),
None => Ok(None),
Expand Down
8 changes: 3 additions & 5 deletions examples/websocket/src/main.rs
Original file line number Diff line number Diff line change
Expand Up @@ -11,20 +11,18 @@ use uhttp::Websocket;
async fn main() -> anyhow::Result<()> {
Server::builder()
.handler(|req, res| async move {
Websocket::upgrade(req, res, |socket| async move {
let (mut socket_sender, mut socket_receiver) = socket.split();

Websocket::upgrade(req, res, |socket_sender, mut socket_receiver| async move {
tokio::task::spawn(async move {
loop {
if socket_sender.send("Hello").await.is_err() {
if socket_sender.send_raw("Hello").await.is_err() {
break;
};
tokio::time::sleep(Duration::from_millis(1000)).await;
}
});

tokio::task::spawn(async move {
while let Ok(Some(msg)) = socket_receiver.recv().await {
while let Ok(Some(msg)) = socket_receiver.recv_raw().await {
println!("GOT: {:?}", msg);
}
});
Expand Down
10 changes: 4 additions & 6 deletions examples/websocket_chat/src/main.rs
Original file line number Diff line number Diff line change
Expand Up @@ -32,9 +32,7 @@ async fn main() -> anyhow::Result<()> {
app.any(
"/api/ws",
move |req, res, Context { chat_service }: Context| async move {
Websocket::upgrade(req, res, |socket| async move {
let (mut socket_sender, mut socket_receiver) = socket.split();

Websocket::upgrade(req, res, |socket_sender, mut socket_receiver| async move {
// Send action
tokio::task::spawn({
let chat_service = Arc::clone(&chat_service);
Expand All @@ -47,7 +45,7 @@ async fn main() -> anyhow::Result<()> {
return;
};

if socket_sender.send(msg).await.is_err() {
if socket_sender.send_raw(msg).await.is_err() {
return;
};

Expand All @@ -62,7 +60,7 @@ async fn main() -> anyhow::Result<()> {
break;
};

if socket_sender.send(msg).await.is_err() {
if socket_sender.send_raw(msg).await.is_err() {
break;
};
}
Expand All @@ -73,7 +71,7 @@ async fn main() -> anyhow::Result<()> {
tokio::task::spawn({
let chat_service = Arc::clone(&chat_service);
async move {
while let Some(msg) = socket_receiver.recv().await? {
while let Some(msg) = socket_receiver.recv_raw().await? {
let uhttp::Message::Text(msg) = msg else {
continue;
};
Expand Down