chore: remove tower dep by vendoring Oneshot

Cargo.toml

@@ -28,8 +28,7 @@ futures-channel = { version = "0.3", optional = true }
 socket2 = { version = "0.5", optional = true, features = ["all"] }
 tracing = { version = "0.1", default-features = false, features = ["std"], optional = true }
 tokio = { version = "1", optional = true, default-features = false  }
-tower-service ={ version = "0.3", optional = true }
-tower = { version = "0.4.1", optional = true, default-features = false, features = ["make", "util"] }
+tower-service = { version = "0.3", optional = true }
 
 [dev-dependencies]
 hyper = { version = "1.4.0", features = ["full"] }
@@ -58,14 +57,14 @@ full = [
     "tokio",
 ]
 
-client = ["hyper/client", "dep:tracing", "dep:futures-channel", "dep:tower", "dep:tower-service"]
+client = ["hyper/client", "dep:tracing", "dep:futures-channel", "dep:tower-service"]
 client-legacy = ["client", "dep:socket2", "tokio/sync"]
 
 server = ["hyper/server"]
 server-auto = ["server", "http1", "http2"]
-server-graceful = ["server", "tokio/sync"]
+server-graceful = ["server", "tokio/sync", "futures-util/alloc"]
 
-service = ["dep:tower", "dep:tower-service"]
+service = ["dep:tower-service"]
 
 http1 = ["hyper/http1"]
 http2 = ["hyper/http2"]

src/client/legacy/connect/mod.rs

@@ -29,7 +29,7 @@
 //! use std::{future::Future, net::SocketAddr, pin::Pin, task::{self, Poll}};
 //! use http::Uri;
 //! use tokio::net::TcpStream;
-//! use tower::Service;
+//! use tower_service::Service;
 //!
 //! #[derive(Clone)]
 //! struct LocalConnector;
@@ -57,7 +57,7 @@
 //! better starting place to extend from.
 //!
 //! [`HttpConnector`]: HttpConnector
-//! [`Service`]: tower::Service
+//! [`Service`]: tower_service::Service
 //! [`Uri`]: ::http::Uri
 //! [`Read`]: hyper::rt::Read
 //! [`Write`]: hyper::rt::Write
@@ -343,8 +343,8 @@ pub(super) mod sealed {
     {
         type _Svc = S;
 
-        fn connect(self, _: Internal, dst: Uri) -> tower::util::Oneshot<S, Uri> {
-            tower::util::Oneshot::new(self, dst)
+        fn connect(self, _: Internal, dst: Uri) -> crate::service::Oneshot<S, Uri> {
+            crate::service::Oneshot::new(self, dst)
         }
     }
 
@@ -357,10 +357,10 @@ pub(super) mod sealed {
     {
         type Connection = T;
         type Error = S::Error;
-        type Future = tower::util::Oneshot<S, Uri>;
+        type Future = crate::service::Oneshot<S, Uri>;
 
         fn connect(self, _: Internal, dst: Uri) -> Self::Future {
-            tower::util::Oneshot::new(self, dst)
+            crate::service::Oneshot::new(self, dst)
         }
     }
 

src/lib.rs

@@ -12,7 +12,7 @@ mod common;
 pub mod rt;
 #[cfg(feature = "server")]
 pub mod server;
-#[cfg(feature = "service")]
+#[cfg(any(feature = "service", feature = "client-legacy"))]
 pub mod service;
 
 mod error;

src/service.rs → src/service/glue.rs

@@ -1,12 +1,11 @@
-//! Service utilities.
-
 use pin_project_lite::pin_project;
 use std::{
     future::Future,
     pin::Pin,
     task::{Context, Poll},
 };
-use tower::{util::Oneshot, ServiceExt};
+
+use super::Oneshot;
 
 /// A tower service converted into a hyper service.
 #[derive(Debug, Copy, Clone)]
@@ -33,7 +32,7 @@ where
 
     fn call(&self, req: R) -> Self::Future {
         TowerToHyperServiceFuture {
-            future: self.service.clone().oneshot(req),
+            future: Oneshot::new(self.service.clone(), req),
         }
     }
 }

src/service/mod.rs

@@ -0,0 +1,11 @@
+//! Service utilities.
+
+#[cfg(feature = "service")]
+mod glue;
+#[cfg(any(feature = "client-legacy", feature = "service"))]
+mod oneshot;
+
+#[cfg(feature = "service")]
+pub use self::glue::TowerToHyperService;
+#[cfg(any(feature = "client-legacy", feature = "service"))]
+pub(crate) use self::oneshot::Oneshot;

src/service/oneshot.rs

@@ -0,0 +1,62 @@
+use pin_project_lite::pin_project;
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{ready, Context, Poll};
+use tower_service::Service;
+
+// Vendored from tower::util to reduce dependencies, the code is small enough.
+
+// Not really pub, but used in a trait for bounds
+pin_project! {
+    #[project = OneshotProj]
+    #[derive(Debug)]
+    pub enum Oneshot<S: Service<Req>, Req> {
+        NotReady {
+            svc: S,
+            req: Option<Req>,
+        },
+        Called {
+            #[pin]
+            fut: S::Future,
+        },
+        Done,
+    }
+}
+
+impl<S, Req> Oneshot<S, Req>
+where
+    S: Service<Req>,
+{
+    pub(crate) const fn new(svc: S, req: Req) -> Self {
+        Oneshot::NotReady {
+            svc,
+            req: Some(req),
+        }
+    }
+}
+
+impl<S, Req> Future for Oneshot<S, Req>
+where
+    S: Service<Req>,
+{
+    type Output = Result<S::Response, S::Error>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        loop {
+            let this = self.as_mut().project();
+            match this {
+                OneshotProj::NotReady { svc, req } => {
+                    let _ = ready!(svc.poll_ready(cx))?;
+                    let fut = svc.call(req.take().expect("already called"));
+                    self.set(Oneshot::Called { fut });
+                }
+                OneshotProj::Called { fut } => {
+                    let res = ready!(fut.poll(cx))?;
+                    self.set(Oneshot::Done);
+                    return Poll::Ready(Ok(res));
+                }
+                OneshotProj::Done => panic!("polled after complete"),
+            }
+        }
+    }
+}