feat(volo-http): support https

examples/Cargo.toml

@@ -87,6 +87,16 @@ path = "src/http/example-http-server.rs"
 name = "example-http-client"
 path = "src/http/example-http-client.rs"
 
+[[bin]]
+name = "http-tls-server"
+path = "src/http/http-tls-server.rs"
+required-features = ["__tls"]
+
+[[bin]]
+name = "http-tls-client"
+path = "src/http/http-tls-client.rs"
+required-features = ["__tls"]
+
 [dependencies]
 anyhow.workspace = true
 async-stream.workspace = true
@@ -108,7 +118,7 @@ pilota.workspace = true
 volo = { path = "../volo" }
 volo-grpc = { path = "../volo-grpc" }
 volo-thrift = { path = "../volo-thrift", features = ["multiplex"] }
-volo-http = { path = "../volo-http", features = ["full"] }
+volo-http = { path = "../volo-http", features = ["default_client", "default_server", "cookie"] }
 
 volo-gen = { path = "./volo-gen" }
 
@@ -118,14 +128,17 @@ rustls = [
     "__tls",
     "volo/rustls",
     "volo-grpc/rustls",
+    "volo-http/rustls",
 ]
 native-tls = [
     "__tls",
     "volo/native-tls",
     "volo-grpc/native-tls",
+    "volo-http/native-tls",
 ]
 native-tls-vendored = [
     "__tls",
     "volo/native-tls-vendored",
     "volo-grpc/native-tls-vendored",
+    "volo-http/native-tls-vendored",
 ]

examples/src/http/example-http-client.rs

@@ -21,7 +21,18 @@ async fn main() -> Result<(), BoxError> {
     tracing::subscriber::set_global_default(subscriber).expect("setting default subscriber failed");
 
     // simple `get` function and dns resolve
-    println!("{}", get("http://www.126.com/").await?.into_string().await?);
+    println!(
+        "{}",
+        get("http://httpbin.org/get").await?.into_string().await?
+    );
+
+    // HTTPS `get`
+    //
+    // If tls is not enabled, the `httpbin.org` will response 400 Bad Request.
+    println!(
+        "{}",
+        get("https://httpbin.org/get").await?.into_string().await?
+    );
 
     // create client by builder
     let client = ClientBuilder::new()

examples/src/http/http-tls-client.rs

@@ -0,0 +1,32 @@
+use volo::net::tls::TlsConnector;
+use volo_http::{body::BodyConversion, client::Client};
+
+#[volo::main]
+async fn main() {
+    let subscriber = tracing_subscriber::FmtSubscriber::builder()
+        .with_max_level(tracing::Level::TRACE)
+        .finish();
+    tracing::subscriber::set_global_default(subscriber).expect("setting default subscriber failed");
+
+    let data_dir = std::path::PathBuf::from_iter([std::env!("CARGO_MANIFEST_DIR"), "data"]);
+    let connector = TlsConnector::builder()
+        .enable_default_root_certs(false)
+        .add_pem_from_file(data_dir.join("tls/ca.pem"))
+        .expect("failed to read ca.pem")
+        .build()
+        .expect("failed to build TlsConnector");
+
+    let client = Client::builder().set_tls_config(connector).build();
+
+    let resp = client
+        .get("https://[::1]:8080/")
+        .expect("invalid uri")
+        .send()
+        .await
+        .expect("request failed")
+        .into_string()
+        .await
+        .expect("response failed to convert to string");
+
+    println!("{resp}");
+}

examples/src/http/http-tls-server.rs

@@ -0,0 +1,50 @@
+//! Test it with:
+//!
+//! ```bash
+//! curl -v --cacert examples/data/tls/ca.pem https://127.0.0.1:8080/
+//! ```
+//!
+//! Or use the tls client directly.
+
+use std::{net::SocketAddr, time::Duration};
+
+use volo::net::tls::ServerTlsConfig;
+use volo_http::server::{
+    layer::TimeoutLayer,
+    route::{get, Router},
+    Server,
+};
+
+async fn index() -> &'static str {
+    "It Works!\n"
+}
+
+#[volo::main]
+async fn main() {
+    let subscriber = tracing_subscriber::FmtSubscriber::builder()
+        .with_max_level(tracing::Level::TRACE)
+        .finish();
+    tracing::subscriber::set_global_default(subscriber).expect("setting default subscriber failed");
+
+    let data_dir = std::path::PathBuf::from_iter([std::env!("CARGO_MANIFEST_DIR"), "data"]);
+    let tls_config = ServerTlsConfig::from_pem_file(
+        data_dir.join("tls/server.pem"),
+        data_dir.join("tls/server.key"),
+    )
+    .expect("failed to load certs");
+
+    let app = Router::new()
+        .route("/", get(index))
+        .layer(TimeoutLayer::new(Duration::from_secs(5)));
+
+    let addr: SocketAddr = "[::]:8080".parse().unwrap();
+    let addr = volo::net::Address::from(addr);
+
+    println!("Listening on {addr}");
+
+    Server::new(app)
+        .tls_config(tls_config)
+        .run(addr)
+        .await
+        .unwrap();
+}

volo-http/Cargo.toml

@@ -52,6 +52,10 @@ tracing.workspace = true
 # server optional
 matchit = { workspace = true, optional = true }
 
+# tls optional
+tokio-rustls = { workspace = true, optional = true }
+tokio-native-tls = { workspace = true, optional = true }
+
 # cookie support
 cookie = { workspace = true, optional = true, features = ["percent-encode"] }
 
@@ -72,11 +76,16 @@ default = []
 default_client = ["client", "json"]
 default_server = ["server", "query", "form", "json"]
 
-full = ["client", "server", "cookie", "query", "form", "json"]
+full = ["client", "server", "rustls", "cookie", "query", "form", "json"]
 
 client = ["hyper/client"] # client core
 server = ["hyper/server", "dep:matchit"] # server core
 
+__tls = []
+rustls = ["__tls", "dep:tokio-rustls", "volo/rustls"]
+native-tls = ["__tls", "dep:tokio-native-tls", "volo/native-tls"]
+native-tls-vendored = ["native-tls", "volo/native-tls-vendored"]
+
 cookie = ["dep:cookie"]
 
 __serde = ["dep:serde"] # a private feature for enabling `serde` by `serde_xxx`

volo-http/src/client/meta.rs

@@ -1,11 +1,12 @@
-use http::{header, HeaderValue};
+use std::error::Error;
+
+use http::header;
+use http_body::Body;
 use motore::service::Service;
 use volo::context::Context;
 
 use crate::{
-    context::{client::Host, ClientContext},
-    error::client::ClientError,
-    request::ClientRequest,
+    context::ClientContext, error::client::ClientError, request::ClientRequest,
     response::ClientResponse,
 };
 
@@ -26,7 +27,9 @@ where
         + Send
         + Sync
         + 'static,
-    B: Send + 'static,
+    B: Body + Send + 'static,
+    B::Data: Send,
+    B::Error: Into<Box<dyn Error + Send + Sync>> + 'static,
 {
     type Response = S::Response;
     type Error = S::Error;
@@ -36,21 +39,36 @@ where
         cx: &mut ClientContext,
         mut req: ClientRequest<B>,
     ) -> Result<Self::Response, Self::Error> {
-        let config = cx.rpc_info().config();
-        let host = match config.host {
-            Host::CalleeName => Some(HeaderValue::from_str(
-                cx.rpc_info().callee().service_name_ref(),
-            )),
-            Host::TargetAddress => cx
-                .rpc_info()
-                .callee()
-                .address()
-                .map(|addr| HeaderValue::from_str(&format!("{}", addr))),
-            Host::None => None,
-        };
-        if let Some(Ok(val)) = host {
-            req.headers_mut().insert(header::HOST, val);
+        // `Content-Length` must be set here because the body may be changed in previous layer(s).
+        let exact_len = req.body().size_hint().exact();
+        if let Some(len) = exact_len {
+            if len > 0 && req.headers().get(header::CONTENT_LENGTH).is_none() {
+                req.headers_mut().insert(header::CONTENT_LENGTH, len.into());
+            }
         }
-        self.inner.call(cx, req).await
+
+        let stat_enable = cx.rpc_info().config().stat_enable;
+
+        if stat_enable {
+            if let Some(req_size) = exact_len {
+                cx.common_stats.set_req_size(req_size);
+            }
+        }
+
+        tracing::trace!("sending request: {} {}", req.method(), req.uri());
+        tracing::trace!("headers: {:?}", req.headers());
+
+        let res = self.inner.call(cx, req).await;
+
+        if stat_enable {
+            if let Ok(response) = res.as_ref() {
+                cx.stats.set_status_code(response.status());
+                if let Some(resp_size) = response.size_hint().exact() {
+                    cx.common_stats.set_resp_size(resp_size);
+                }
+            }
+        }
+
+        res
     }
 }