h2

1 files changed, 27 insertions, 31 deletions

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);
         }