Update http module

- Some docs
- Add `RequestParams` (extension)
- Rename `HttpServer` to `LuaHttpServer`

Author: khvzak

Cargo.toml

@@ -45,7 +45,7 @@ http-serde-ext = { version = "1.0", optional = true }
 http-body = { version = "1.0", optional = true }
 http-body-util = { version = "0.1", optional = true }
 hyper = { version = "1.5", optional = true, features = ["http1", "http2", "server"] }
-hyper-util = { version = "0.1", optional = true, features = ["tokio", "server", "server-auto", "server-graceful"] }
+hyper-util = { version = "0.1", optional = true, features = ["tokio", "server", "server-auto", "server-graceful", "client-legacy"] }
 
 # reqwest
 reqwest = { version = "0.12", features = ["cookies", "gzip", "brotli", "multipart", "stream"], optional = true }

src/http/body.rs

@@ -41,10 +41,12 @@ impl Default for LuaBody {
 }
 
 impl LuaBody {
+    /// Creates a new empty body.
     pub const fn new() -> Self {
         LuaBody(Inner::Bytes(Bytes::new()))
     }
 
+    /// Buffers the entire body into memory.
     async fn buffer(&mut self) -> Result<(), Error> {
         match self {
             LuaBody(Inner::Bytes(_)) => Ok(()),
@@ -56,6 +58,7 @@ impl LuaBody {
         }
     }
 
+    /// Consumes the body if it is not already buffered, returning a buffered body.
     fn consume_if_unbuffered(&mut self) -> Self {
         match self {
             LuaBody(Inner::Bytes(bytes)) => LuaBody(Inner::Bytes(bytes.clone())),
@@ -65,12 +68,14 @@ impl LuaBody {
 }
 
 impl From<Bytes> for LuaBody {
+    #[inline]
     fn from(bytes: Bytes) -> Self {
         LuaBody(Inner::Bytes(bytes))
     }
 }
 
 impl From<Incoming> for LuaBody {
+    #[inline]
     fn from(incoming: Incoming) -> Self {
         LuaBody(Inner::Incoming {
             incoming,

src/http/headers.rs

@@ -197,6 +197,7 @@ fn set_headers_metatable(lua: &Lua, headers: &Table) -> Result<()> {
     headers.set_metatable(Some(metatable))
 }
 
+/// Extension trait for converting Lua strings to header names and values.
 pub(crate) trait LuaHeaderValueExt {
     fn from_lua(value: &LuaString) -> Result<Self>
     where
@@ -217,6 +218,7 @@ impl LuaHeaderValueExt for HeaderValue {
     }
 }
 
+/// Extension trait for [`http::HeaderMap`] to provide Lua-friendly methods.
 pub(crate) trait LuaHeaderMapExt {
     fn get(&self, lua: &Lua, name: &LuaString) -> Result<Option<LuaString>>;
 

src/http/method.rs

@@ -1,6 +1,6 @@
 use mlua::{ExternalResult, FromLua, Lua, Result, String as LuaString, Value};
 
-/// A Lua userdata wrapper around [`http::Method`].
+/// A Lua wrapper around [`http::Method`].
 #[derive(Clone, Default, Debug)]
 pub struct LuaMethod(pub http::Method);
 

src/http/mod.rs

@@ -5,15 +5,15 @@ pub use headers::LuaHeaders;
 pub use method::LuaMethod;
 pub use request::LuaRequest;
 pub use response::LuaResponse;
+pub use server::LuaHttpServer;
 
-#[allow(unused_imports)]
 pub(crate) use headers::LuaHeaderMapExt;
 
 /// A loader for the `http` module.
 fn loader(lua: &Lua) -> Result<Table> {
     let t = lua.create_table()?;
     t.set("Headers", lua.create_proxy::<LuaHeaders>()?)?;
-    t.set("HttpServer", lua.create_proxy::<server::HttpServer>()?)?;
+    t.set("HttpServer", lua.create_proxy::<LuaHttpServer>()?)?;
     t.set("Request", lua.create_proxy::<LuaRequest>()?)?;
     t.set("Response", lua.create_proxy::<LuaResponse>()?)?;
     Ok(t)

src/http/request.rs

@@ -3,17 +3,18 @@ use std::mem;
 use http::request::{Parts, Request};
 use http_body_util::Either as EitherBody;
 use hyper::body::Incoming;
-use mlua::{AnyUserData, Error, FromLua, Lua, Result, String as LuaString, UserData, UserDataMethods, Value};
+use mlua::{
+    AnyUserData, Error, FromLua, Lua, MetaMethod, Result, String as LuaString, Table, UserData,
+    UserDataMethods, Value,
+};
 
-use super::headers::LuaHeaderMapExt;
-use crate::http::{LuaBody, LuaHeaders, LuaMethod};
+use crate::http::{LuaBody, LuaHeaderMapExt, LuaHeaders, LuaMethod};
 use crate::time::Duration;
 
-/// A Lua-accessible HTTP request
+/// A Lua wrapper around [`http::Request`].
 pub struct LuaRequest {
     pub(crate) head: Parts,
     pub(crate) body: EitherBody<LuaBody, AnyUserData>,
-    pub(crate) timeout: Option<Duration>,
 }
 
 impl Default for LuaRequest {
@@ -23,12 +24,12 @@ impl Default for LuaRequest {
         LuaRequest {
             head,
             body: EitherBody::Left(LuaBody::new()),
-            timeout: None,
         }
     }
 }
 
 impl LuaRequest {
+    /// Consumes the LuaRequest and returns its parts.
     pub fn into_parts(self) -> (Parts, LuaBody) {
         let LuaRequest { head, body, .. } = self;
         let body = match body {
@@ -37,6 +38,14 @@ impl LuaRequest {
         };
         (head, body)
     }
+
+    #[allow(unused)]
+    pub(crate) fn params(&self) -> RequestParams {
+        (self.head.extensions)
+            .get::<RequestParams>()
+            .cloned()
+            .unwrap_or_default()
+    }
 }
 
 impl UserData for LuaRequest {
@@ -92,7 +101,7 @@ impl UserData for LuaRequest {
         registry.add_method_mut("body", |lua, this, ()| {
             match &mut this.body {
                 EitherBody::Left(body) => {
-                    // Move the body to Lua
+                    // Move the body into Lua
                     let ud_body = lua.create_userdata(mem::take(body))?;
                     this.body = EitherBody::Right(ud_body.clone());
                     Ok(ud_body)
@@ -105,6 +114,18 @@ impl UserData for LuaRequest {
             this.body = EitherBody::Left(body);
             Ok(())
         });
+
+        registry.add_meta_method(MetaMethod::ToString, |_, this, ()| {
+            let mut buf = String::with_capacity(1024);
+            let (method, uri, version) = (&this.head.method, &this.head.uri, this.head.version);
+            buf.push_str(&format!("{method} {uri} {version:?}\n"));
+            // Iterate headers
+            for (name, value) in &this.head.headers {
+                let value = String::from_utf8_lossy(value.as_bytes());
+                buf.push_str(&format!("{name}: {value}\n"));
+            }
+            Ok(buf)
+        });
     }
 }
 
@@ -114,7 +135,6 @@ impl From<Request<Incoming>> for LuaRequest {
         LuaRequest {
             head,
             body: EitherBody::Left(LuaBody::from(body)),
-            timeout: None,
         }
     }
 }
@@ -140,21 +160,36 @@ impl FromLua for LuaRequest {
                 }
                 // TODO: json, form, etc
 
-                // Additional parameters
-                let timeout = opt_param!(Duration, Some(&params), "timeout")?;
+                // Additional custom parameters
+                head.extensions.insert(RequestParams::from_table(&params)?);
 
                 Ok(Self {
                     head,
                     body: EitherBody::Left(body),
-                    timeout,
                 })
             }
             Value::UserData(ud) if ud.is::<Self>() => ud.take::<Self>(),
             _ => Err(Error::FromLuaConversionError {
                 from: value.type_name(),
                 to: "Request".to_string(),
-                message: Some("expected Table or Request".to_string()),
+                message: Some("expected Table or Request userdata".to_string()),
             }),
         }
     }
 }
+
+/// Additional custom request parameters
+#[derive(Clone, Debug, Default)]
+pub(crate) struct RequestParams {
+    pub(crate) timeout: Option<Duration>,
+}
+
+impl RequestParams {
+    pub(crate) fn from_table(table: &Table) -> Result<Self> {
+        let mut params = RequestParams::default();
+        if let Some(timeout) = opt_param!(Duration, Some(table), "timeout")? {
+            params.timeout = Some(timeout);
+        }
+        Ok(params)
+    }
+}

src/http/response.rs

@@ -13,14 +13,20 @@ use mlua::{
 use super::headers::LuaHeaderMapExt;
 use crate::http::{LuaBody, LuaHeaders};
 
-/// A Lua-accessible HTTP response
+/// A Lua wrapper around [`http::Response`].
 pub struct LuaResponse {
     pub(crate) head: Parts,
     pub(crate) body: EitherBody<LuaBody, AnyUserData>,
 }
 
+impl Default for LuaResponse {
+    fn default() -> Self {
+        LuaResponse::new(LuaBody::new())
+    }
+}
+
 impl LuaResponse {
-    /// Create a new Response with the given status code
+    /// Create a new Response with the given body.
     pub fn new(body: LuaBody) -> Self {
         let head = Response::new(()).into_parts().0;
         let body = EitherBody::Left(body);
@@ -100,11 +106,8 @@ impl UserData for LuaResponse {
 
         registry.add_meta_method(MetaMethod::ToString, |_, this, ()| {
             let mut buf = String::with_capacity(1024);
-            let (version, status, reason) = (
-                &this.head.version,
-                this.head.status.as_u16(),
-                this.head.status.canonical_reason().unwrap_or(""),
-            );
+            let (version, status) = (this.head.version, this.head.status);
+            let reason = status.canonical_reason().unwrap_or("");
             buf.push_str(&format!("{version:?} {status} {reason}\n"));
             // Iterate headers
             for (name, value) in &this.head.headers {

src/http/server.rs

@@ -34,13 +34,13 @@ where
 }
 
 /// HTTP server that can handle HTTP/1 and HTTP/2 connections
-pub struct HttpServer {
+pub struct LuaHttpServer {
     conn: ConnBuilder<LocalExec>,
     graceful: Arc<Mutex<GracefulShutdown>>,
     shutdown_notify: Arc<Mutex<tokio::sync::watch::Sender<()>>>,
 }
 
-impl HttpServer {
+impl LuaHttpServer {
     pub fn new(params: Option<Table>) -> Result<Self> {
         let mut conn = ConnBuilder::new(LocalExec);
 
@@ -99,7 +99,7 @@ impl HttpServer {
         conn.http1().timer(TokioTimer::new());
         conn.http2().timer(TokioTimer::new());
 
-        Ok(HttpServer {
+        Ok(LuaHttpServer {
             conn,
             graceful: Default::default(),
             shutdown_notify: Default::default(),
@@ -179,9 +179,9 @@ impl HttpServer {
     }
 }
 
-impl UserData for HttpServer {
+impl UserData for LuaHttpServer {
     fn register(registry: &mut UserDataRegistry<Self>) {
-        registry.add_function("new", |_: &Lua, params| HttpServer::new(params));
+        registry.add_function("new", |_: &Lua, params| Self::new(params));
 
         registry.add_async_method(
             "serve_connection",

src/net/tcp/mod.rs

@@ -3,7 +3,7 @@ use mlua::{Lua, Result, Table};
 pub use listener::{LuaTcpListener, listen};
 pub use stream::{LuaTcpStream, connect};
 
-use socket::{SocketOptions, LuaTcpSocket};
+use socket::{LuaTcpSocket, SocketOptions};
 
 /// A loader for the `net/tcp` module.
 fn loader(lua: &Lua) -> Result<Table> {

src/net/tcp/stream.rs

@@ -16,6 +16,7 @@ use crate::time::Duration;
 /// Lua wrapper around tokio [`TcpStream`].
 pub struct LuaTcpStream {
     pub(crate) stream: TcpStream,
+    #[allow(unused)]
     pub(crate) host: Option<String>,
     pub(crate) read_timeout: Option<Duration>,
     pub(crate) write_timeout: Option<Duration>,