h2

4 files changed, 36 insertions, 33 deletions

diff --git a/Cargo.lock b/Cargo.lock
index 11cf932..cd3a1bf 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -794,6 +794,7 @@ dependencies = [
  "http-body",
  "hyper",
  "pin-project-lite",
+ "tokio",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index fc77e7d..6653d38 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -6,7 +6,13 @@ edition = "2021"
 [dependencies]
 # HTTP
 hyper = { version = "1.4.1", features = ["server", "client", "http1", "http2"] }
-hyper-util = "0.1.7"
+hyper-util = { version = "0.1.7", features = [
+    "server-auto",
+    "server",
+    "http1",
+    "http2",
+    "tokio",
+] }
 http-body-util = "0.1.2"
 headers = "0.4.0"
 percent-encoding = "2.3.1"
diff --git a/readme.md b/readme.md
index 348cafd..9e96f8e 100644
--- a/readme.md
+++ b/readme.md
@@ -4,7 +4,7 @@ a simple stupid reverse proxy
 
 ## Features
 
-- HTTP/1.1
+- HTTP/1.1 and HTTP/2
 - Simple to configure (see below)
 - Somewhat fast (about 150k req/s on a rpi5 for simple routes)
 - Composable modules
diff --git a/src/main.rs b/src/main.rs
index e286924..8ca86cb 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -20,10 +20,10 @@ use hyper::{
     body::Incoming,
     header::{CONTENT_TYPE, HOST, SERVER},
     http::HeaderValue,
-    server::conn::http1,
     service::service_fn,
     Request, Response, StatusCode,
 };
+use hyper_util::rt::TokioExecutor;
 use log::{debug, error, info, warn, LevelFilter};
 use modules::{NodeContext, MODULES};
 use std::{
@@ -150,10 +150,7 @@ async fn serve_https(state: Arc<State>) -> Result<()> {
         let mut cfg = rustls::ServerConfig::builder()
             .with_no_client_auth()
             .with_cert_resolver(Arc::new(certs));
-        cfg.alpn_protocols = vec![
-            // b"h2".to_vec(),
-            b"http/1.1".to_vec(),
-        ];
+        cfg.alpn_protocols = vec![b"h2".to_vec(), b"http/1.1".to_vec()];
         Arc::new(cfg)
     };
     let tls_acceptor = Arc::new(TlsAcceptor::from(tls_config));
@@ -184,34 +181,33 @@ pub async fn serve_stream<T: Unpin + Send + 'static + hyper::rt::Read + hyper::r
     addr: SocketAddr,
 ) {
     if let Ok(_semaphore) = state.l_incoming.try_acquire() {
-        let conn = http1::Builder::new()
-            .serve_connection(
-                stream,
-                service_fn(|req| {
-                    let state = state.clone();
-                    async move {
-                        let config = state.config.read().await.clone();
-                        match service(state, config, req, addr).await {
-                            Ok(r) => Ok(r),
-                            Err(ServiceError::Hyper(e)) => Err(e),
-                            Err(error) => Ok({
-                                warn!("service error {addr} {error:?}");
-                                let mut resp = Response::new(format!(
-                                    "Sorry, we were unable to process your request: {error}"
-                                ));
-                                *resp.status_mut() = StatusCode::BAD_REQUEST;
-                                resp.headers_mut()
-                                    .insert(CONTENT_TYPE, HeaderValue::from_static("text/plain"));
-                                resp.headers_mut()
-                                    .insert(SERVER, HeaderValue::from_static("gnix"));
-                                resp
-                            }
-                            .map(|b| b.map_err(|e| match e {}).boxed())),
+        let builder = hyper_util::server::conn::auto::Builder::new(TokioExecutor::new());
+        let conn = builder.serve_connection_with_upgrades(
+            stream,
+            service_fn(|req| {
+                let state = state.clone();
+                async move {
+                    let config = state.config.read().await.clone();
+                    match service(state, config, req, addr).await {
+                        Ok(r) => Ok(r),
+                        Err(ServiceError::Hyper(e)) => Err(e),
+                        Err(error) => Ok({
+                            warn!("service error {addr} {error:?}");
+                            let mut resp = Response::new(format!(
+                                "Sorry, we were unable to process your request: {error}"
+                            ));
+                            *resp.status_mut() = StatusCode::BAD_REQUEST;
+                            resp.headers_mut()
+                                .insert(CONTENT_TYPE, HeaderValue::from_static("text/plain"));
+                            resp.headers_mut()
+                                .insert(SERVER, HeaderValue::from_static("gnix"));
+                            resp
                         }
+                        .map(|b| b.map_err(|e| match e {}).boxed())),
                     }
-                }),
-            )
-            .with_upgrades();
+                }
+            }),
+        );
         if let Err(err) = conn.await {
             warn!("error: {:?}", err);
         }