feat(deps): upgrade dependencies to http v1 & hyper v1

Cargo.toml

@@ -33,7 +33,7 @@ path = "src/lib.rs"
 [features]
 default = []
 actix-compat = [ "actix-web" ]
-warp-compat = [ "warp", "hyper" ]
+warp-compat = [ "warp" ]
 all = [ "actix-compat", "warp-compat" ]
 
 [[example]]
@@ -48,10 +48,11 @@ required-features = [ "warp-compat" ]
 bytes = "1.5.0"
 futures = "0.3.29"
 handlebars = "4.5.0"
-headers = "0.3.9"
+headers = "0.4.0"
 htmlescape = "0.3.1"
-http = "0.2.11"
-http-body = "0.4.5"
+http = "1.0.0"
+http-body = "1.0.0"
+http-body-util = "0.1.0"
 lazy_static = "1.4.0"
 libc = "0.2.150"
 log = "0.4.20"
@@ -69,14 +70,15 @@ uuid = { version = "1.6.1", features = ["v4"] }
 xml-rs = "0.8.19"
 xmltree = "0.10.3"
 
-hyper = {version = "0.14.27", optional = true }
+hyper = {version = "1.1.0", optional = true }
 warp = { version = "0.3.6", optional = true }
-actix-web = { version = "4.4.0", optional = true }
+actix-web = { version = "4.4.1", optional = true }
 
 [dev-dependencies]
 clap = { version = "4.4.8", features = ["derive"] }
 env_logger = "0.10.1"
-hyper = { version = "0.14.27", features = [ "http1", "http2", "server", "stream", "runtime" ] }
+hyper = { version = "1.1.0", features = [ "http1", "http2", "server" ] }
+hyper-util = { version = "0.1.2", features = [ "http1", "http2", "server", "server-auto", "tokio" ] }
 tokio = { version = "1.34.0", features = ["full"] }
 time = { version = "0.3.30", default-features = false, features = ["local-offset"] }
 

examples/actix.rs

@@ -1,5 +1,6 @@
 use std::io;
 
+use actix_web::web::Data;
 use actix_web::{web, App, HttpServer};
 use webdav_handler::actix::*;
 use webdav_handler::{fakels::FakeLs, localfs::LocalFs, DavConfig, DavHandler};
@@ -28,7 +29,7 @@ async fn main() -> io::Result<()> {
 
     HttpServer::new(move || {
         App::new()
-            .data(dav_server.clone())
+            .app_data(Data::new(dav_server.clone()))
             .service(web::resource("/{tail:.*}").to(dav_handler))
     })
     .bind(addr)?

examples/hyper.rs

@@ -1,31 +1,42 @@
+use hyper::service::service_fn;
+use hyper_util::rt::{TokioExecutor, TokioIo};
 use std::convert::Infallible;
+use std::net::SocketAddr;
+use tokio::net::TcpListener;
 use webdav_handler::{fakels::FakeLs, localfs::LocalFs, DavHandler};
 
 #[tokio::main]
-async fn main() {
+async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     env_logger::init();
     let dir = "/tmp";
-    let addr = ([127, 0, 0, 1], 4918).into();
+    let addr = SocketAddr::from(([127, 0, 0, 1], 4918));
 
     let dav_server = DavHandler::builder()
         .filesystem(LocalFs::new(dir, false, false, false))
         .locksystem(FakeLs::new())
+        .autoindex(true, None)
         .build_handler();
 
-    let make_service = hyper::service::make_service_fn(move |_| {
-        let dav_server = dav_server.clone();
-        async move {
-            let func = move |req| {
-                let dav_server = dav_server.clone();
-                async move { Ok::<_, Infallible>(dav_server.handle(req).await) }
-            };
-            Ok::<_, Infallible>(hyper::service::service_fn(func))
-        }
-    });
-
+    let listener = TcpListener::bind(addr).await?;
     println!("hyper example: listening on {:?} serving {}", addr, dir);
-    let _ = hyper::Server::bind(&addr)
-        .serve(make_service)
-        .await
-        .map_err(|e| eprintln!("server error: {}", e));
+
+    loop {
+        let (stream, _) = listener.accept().await?;
+        let io = TokioIo::new(stream);
+        let dav_server = dav_server.clone();
+        tokio::task::spawn(async move {
+            if let Err(err) = hyper_util::server::conn::auto::Builder::new(TokioExecutor::new())
+                .serve_connection(
+                    io,
+                    service_fn(move |req| {
+                        let dav_server = dav_server.clone();
+                        async move { Ok::<_, Infallible>(dav_server.handle(req).await) }
+                    }),
+                )
+                .await
+            {
+                println!("Error serving connection: {:?}", err);
+            }
+        });
+    }
 }

examples/sample-litmus-server.rs

@@ -12,8 +12,9 @@ use std::str::FromStr;
 
 use clap::Parser;
 use env_logger;
-use futures::future::TryFutureExt;
-use hyper;
+use hyper::service::service_fn;
+use hyper_util::rt::{TokioExecutor, TokioIo};
+use tokio::net::TcpListener;
 
 use headers::{authorization::Basic, Authorization, HeaderMapExt};
 
@@ -50,7 +51,10 @@ impl Server {
         }
     }
 
-    async fn handle(&self, req: hyper::Request<hyper::Body>) -> Result<hyper::Response<Body>, Infallible> {
+    async fn handle(
+        &self,
+        req: hyper::Request<hyper::body::Incoming>,
+    ) -> Result<hyper::Response<Body>, Infallible> {
         let user = if self.auth {
             // we want the client to authenticate.
             match req.headers().typed_get::<Authorization<Basic>>() {
@@ -113,27 +117,30 @@ async fn main() -> Result<(), Box<dyn Error>> {
     let memls = args.memfs || args.memls;
     let fakels = args.fakels;
     let auth = args.auth;
-
-    let dav_server = Server::new(dir.to_string(), memls, fakels, auth);
-    let make_service = hyper::service::make_service_fn(|_| {
-        let dav_server = dav_server.clone();
-        async move {
-            let func = move |req| {
-                let dav_server = dav_server.clone();
-                async move { dav_server.clone().handle(req).await }
-            };
-            Ok::<_, hyper::Error>(hyper::service::service_fn(func))
-        }
-    });
-
     let addr = format!("0.0.0.0:{}", args.port);
     let addr = SocketAddr::from_str(&addr)?;
+    let dav_server = Server::new(dir.to_string(), memls, fakels, auth);
 
-    let server = hyper::Server::try_bind(&addr)?
-        .serve(make_service)
-        .map_err(|e| eprintln!("server error: {}", e));
-
+    let listener = TcpListener::bind(addr).await?;
     println!("Serving {} on {}", name, args.port);
-    let _ = server.await;
-    Ok(())
+
+    loop {
+        let (stream, _) = listener.accept().await?;
+        let io = TokioIo::new(stream);
+        let dav_server = dav_server.clone();
+        tokio::task::spawn(async move {
+            if let Err(err) = hyper_util::server::conn::auto::Builder::new(TokioExecutor::new())
+                .serve_connection(
+                    io,
+                    service_fn(move |req| {
+                        let dav_server = dav_server.clone();
+                        async move { dav_server.handle(req).await }
+                    }),
+                )
+                .await
+            {
+                println!("Error serving connection: {:?}", err);
+            }
+        });
+    }
 }

examples/warp.rs

@@ -8,6 +8,6 @@ async fn main() {
     let addr: SocketAddr = ([127, 0, 0, 1], 4918).into();
 
     println!("warp example: listening on {:?} serving {}", addr, dir);
-    let warpdav = dav_dir(dir, true, true);
+    let warpdav = dav_dir(dir, true, true, None);
     warp::serve(warpdav).run(addr).await;
 }

src/actix.rs

@@ -18,6 +18,7 @@ use std::pin::Pin;
 use std::task::{Context, Poll};
 
 use actix_web::error::PayloadError;
+use actix_web::http::StatusCode;
 use actix_web::{dev, Error, FromRequest, HttpRequest, HttpResponse};
 use bytes::Bytes;
 use futures::{future, Stream};
@@ -28,7 +29,7 @@ use pin_project::pin_project;
 /// Wraps `http::Request<DavBody>` and implements `actix_web::FromRequest`.
 pub struct DavRequest {
     pub request: http::Request<DavBody>,
-    prefix:      Option<String>,
+    prefix: Option<String>,
 }
 
 impl DavRequest {
@@ -39,17 +40,24 @@ impl DavRequest {
 }
 
 impl FromRequest for DavRequest {
-    type Config = ();
     type Error = Error;
     type Future = future::Ready<Result<DavRequest, Error>>;
 
     fn from_request(req: &HttpRequest, payload: &mut dev::Payload) -> Self::Future {
+        let http_version = match req.version() {
+            actix_web::http::Version::HTTP_09 => http::Version::HTTP_09,
+            actix_web::http::Version::HTTP_10 => http::Version::HTTP_10,
+            actix_web::http::Version::HTTP_11 => http::Version::HTTP_11,
+            actix_web::http::Version::HTTP_2 => http::Version::HTTP_2,
+            actix_web::http::Version::HTTP_3 => http::Version::HTTP_3,
+            _ => return future::ready(Err(io::Error::from(io::ErrorKind::Unsupported).into())),
+        };
         let mut builder = http::Request::builder()
-            .method(req.method().to_owned())
-            .uri(req.uri().to_owned())
-            .version(req.version().to_owned());
+            .method(req.method().as_str())
+            .uri(req.uri().to_string())
+            .version(http_version);
         for (name, value) in req.headers().iter() {
-            builder = builder.header(name, value);
+            builder = builder.header(name.as_str(), value.as_ref());
         }
         let path = req.match_info().path();
         let tail = req.match_info().unprocessed();
@@ -80,34 +88,23 @@ impl http_body::Body for DavBody {
     type Data = Bytes;
     type Error = io::Error;
 
-    fn poll_data(
+    fn poll_frame(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Self::Data, Self::Error>>>
-    {
+    ) -> Poll<Option<Result<http_body::Frame<Self::Data>, Self::Error>>> {
         let this = self.project();
         match this.body.poll_next(cx) {
-            Poll::Ready(Some(Ok(data))) => Poll::Ready(Some(Ok(data))),
-            Poll::Ready(Some(Err(err))) => {
-                Poll::Ready(Some(Err(match err {
-                    PayloadError::Incomplete(Some(err)) => err,
-                    PayloadError::Incomplete(None) => io::ErrorKind::BrokenPipe.into(),
-                    PayloadError::Io(err) => err,
-                    other => io::Error::new(io::ErrorKind::Other, format!("{:?}", other)),
-                })))
-            },
+            Poll::Ready(Some(Ok(data))) => Poll::Ready(Some(Ok(http_body::Frame::data(data)))),
+            Poll::Ready(Some(Err(err))) => Poll::Ready(Some(Err(match err {
+                PayloadError::Incomplete(Some(err)) => err,
+                PayloadError::Incomplete(None) => io::ErrorKind::BrokenPipe.into(),
+                PayloadError::Io(err) => err,
+                other => io::Error::new(io::ErrorKind::Other, format!("{:?}", other)),
+            }))),
             Poll::Ready(None) => Poll::Ready(None),
             Poll::Pending => Poll::Pending,
         }
     }
-
-    fn poll_trailers(
-        self: Pin<&mut Self>,
-        _cx: &mut Context,
-    ) -> Poll<Result<Option<http::HeaderMap>, Self::Error>>
-    {
-        Poll::Ready(Ok(None))
-    }
 }
 
 /// `http::Response` compatibility.
@@ -122,14 +119,16 @@ impl From<http::Response<crate::body::Body>> for DavResponse {
 }
 
 impl actix_web::Responder for DavResponse {
+    type Body = actix_web::body::BoxBody;
 
     fn respond_to(self, _req: &HttpRequest) -> HttpResponse {
         use crate::body::{Body, BodyType};
 
         let (parts, body) = self.0.into_parts();
-        let mut builder = HttpResponse::build(parts.status);
+        let status = StatusCode::from_u16(parts.status.as_u16()).unwrap();
+        let mut builder = HttpResponse::build(status);
         for (name, value) in parts.headers.into_iter() {
-            builder.append_header((name.unwrap(), value));
+            builder.append_header((name.unwrap().as_str(), value.as_ref()));
         }
         // I noticed that actix-web returns an empty chunked body
         // (\r\n0\r\n\r\n) and _no_ Transfer-Encoding header on

src/body.rs

@@ -7,7 +7,6 @@ use std::task::{Context, Poll};
 
 use bytes::{Buf, Bytes};
 use futures::stream::Stream;
-use http::header::HeaderMap;
 use http_body::Body as HttpBody;
 
 use crate::async_stream::AsyncStream;
@@ -52,16 +51,11 @@ impl HttpBody for Body {
     type Data = Bytes;
     type Error = io::Error;
 
-    fn poll_data(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Result<Self::Data, Self::Error>>> {
-        self.poll_next(cx)
-    }
-
-    fn poll_trailers(
+    fn poll_frame(
         self: Pin<&mut Self>,
-        _cx: &mut Context,
-    ) -> Poll<Result<Option<HeaderMap>, Self::Error>>
-    {
-        Poll::Ready(Ok(None))
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<http_body::Frame<Self::Data>, Self::Error>>> {
+        self.poll_next(cx).map_ok(http_body::Frame::data)
     }
 }
 
@@ -117,21 +111,12 @@ where
     type Data = ReqData;
     type Error = ReqError;
 
-    fn poll_data(
+    fn poll_frame(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Self::Data, Self::Error>>>
-    {
+    ) -> Poll<Option<Result<http_body::Frame<Self::Data>, Self::Error>>> {
         let this = self.project();
-        this.body.poll_next(cx)
-    }
-
-    fn poll_trailers(
-        self: Pin<&mut Self>,
-        _cx: &mut Context,
-    ) -> Poll<Result<Option<HeaderMap>, Self::Error>>
-    {
-        Poll::Ready(Ok(None))
+        this.body.poll_next(cx).map_ok(http_body::Frame::data)
     }
 }