finish upgrade hyper and http to version 1

Cargo.toml

@@ -37,8 +37,8 @@ base64 = "0.22"
 futures = "0.3"
 http = "1"
 http-body-util = "0.1"
-hyper = { version = "1", features = ["http2"] }
-hyper-util = "0.1"
+hyper = "1"
+hyper-util = { version = "0.1.5", features = ["client-legacy", "server-auto", "http1", "http2", "server-graceful"] }
 hyper-rustls = { version = "0.27", optional = true, default-features = false, features = ["http2"] }
 hyper-tls = { version = "0.6.0", optional = true }
 itertools = "0.12"
@@ -47,18 +47,17 @@ percent-encoding = "2"
 rustls = { version = "^0.23", optional = true, features = ["ring"] }
 rustls-pemfile = { version = "1.0.1", optional = true }
 seahash = "4"
-serde = {version = "1.0", features = ["derive"]}
+serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 time = { version = "0.3.7", features = ["local-offset", "parsing", "serde"] }
-tokio = { version = "1.0", features = ["fs", "macros", "io-std", "io-util", "time", "sync", "rt"] }
-tower-service = "^0.3.1"
+tokio = { version = "1.0", features = [ "fs", "macros", "io-std", "io-util", "time", "sync", "rt"] }
 url = "2"
 
 [dev-dependencies]
 httptest = "0.16"
-env_logger = "0.11"
+env_logger = "0.10"
 tempfile = "3.1"
-webbrowser = "1"
+webbrowser = "0.8"
 hyper-rustls = "0.27"
 
 [workspace]

examples/custom_client.rs

@@ -5,30 +5,22 @@
 //!
 //! It is also a better use of resources (memory, sockets, etc.)
 
-use std::error::Error as StdError;
+use hyper_util::client::legacy::connect::Connect;
 
-use http::Uri;
-use hyper_util::client::legacy::connect::Connection;
-use tokio::io::{AsyncRead, AsyncWrite};
-use tower_service::Service;
-
-async fn r#use<S>(
-    client: hyper_util::client::legacy::Client<S, String>,
-    authenticator: yup_oauth2::authenticator::Authenticator<S>,
+async fn r#use<C>(
+    client: hyper_util::client::legacy::Client<C, String>,
+    authenticator: yup_oauth2::authenticator::Authenticator<C>,
 ) -> Result<(), Box<dyn std::error::Error + Send + Sync>>
 where
-    S: Service<Uri> + Clone + Send + Sync + 'static,
-    S::Response: Connection + AsyncRead + AsyncWrite + Send + Unpin + 'static,
-    S::Future: Send + Unpin + 'static,
-    S::Error: Into<Box<dyn StdError + Send + Sync>>,
+    C: Connect + Clone + Send + Sync + 'static,
 {
     let access_token = authenticator.token(&["email"]).await?;
     let request = http::Request::get("https://example.com")
         .header(
             http::header::AUTHORIZATION,
             format!("Bearer {}", access_token.token().ok_or("no access token")?),
         )
-        .body(hyper::body::Body::empty())?;
+        .body(String::new())?;
     let response = client.request(request).await?;
     drop(response); // Implementing handling of the response is left as an exercise for the reader.
     Ok(())
@@ -41,15 +33,16 @@ async fn main() {
     let secret = yup_oauth2::read_service_account_key(google_credentials)
         .await
         .expect("$GOOGLE_APPLICATION_CREDENTIALS is not a valid service account key");
-    let client = hyper_util::client::legacy::Client::builder(hyper_util::rt::TokioExecutor::new()).build(
-        hyper_rustls::HttpsConnectorBuilder::new()
-            .with_native_roots()
-            .expect("failed to find native root certificates")
-            .https_only()
-            .enable_http1()
-            .enable_http2()
-            .build(),
-    );
+    let client = hyper_util::client::legacy::Client::builder(hyper_util::rt::TokioExecutor::new())
+        .build(
+            hyper_rustls::HttpsConnectorBuilder::new()
+                .with_native_roots()
+                .expect("failed to find native root certificates")
+                .https_only()
+                .enable_http1()
+                .enable_http2()
+                .build(),
+        );
     let authenticator =
         yup_oauth2::ServiceAccountAuthenticator::with_client(secret, client.clone())
             .build()

src/access_token.rs

@@ -7,11 +7,7 @@
 //! access token of the other service by generating a new token.
 use crate::error::Error;
 use crate::types::TokenInfo;
-use http::Uri;
-use hyper_util::client::legacy::connect::Connection;
-use std::error::Error as StdError;
-use tokio::io::{AsyncRead, AsyncWrite};
-use tower_service::Service;
+use hyper_util::client::legacy::connect::Connect;
 
 /// the flow for the access token authenticator
 pub struct AccessTokenFlow {
@@ -20,17 +16,14 @@ pub struct AccessTokenFlow {
 
 impl AccessTokenFlow {
     /// just return the access token
-    pub(crate) async fn token<S, T>(
+    pub(crate) async fn token<C, B, T>(
         &self,
-        _hyper_client: &hyper_util::client::legacy::Client<S, String>,
+        _hyper_client: &hyper_util::client::legacy::Client<C, B>,
         _scopes: &[T],
     ) -> Result<TokenInfo, Error>
     where
         T: AsRef<str>,
-        S: Service<Uri> + Clone + Send + Sync + 'static,
-        S::Response: Connection + AsyncRead + AsyncWrite + Send + Unpin + 'static,
-        S::Future: Send + Unpin + 'static,
-        S::Error: Into<Box<dyn StdError + Send + Sync>>,
+        C: Connect + Clone + Send + Sync + 'static,
     {
         Ok(TokenInfo {
             access_token: Some(self.access_token.clone()),

src/application_default_credentials.rs

@@ -1,11 +1,7 @@
 use crate::error::Error;
 use crate::types::TokenInfo;
-use http::Uri;
 use http_body_util::BodyExt;
-use hyper_util::client::legacy::connect::{Connect, Connection};
-use std::error::Error as StdError;
-use tokio::io::{AsyncRead, AsyncWrite};
-use tower_service::Service;
+use hyper_util::client::legacy::connect::Connect;
 
 /// Provide options for the Application Default Credential Flow, mostly used for testing
 #[derive(Default, Clone, Debug)]
@@ -24,26 +20,23 @@ impl ApplicationDefaultCredentialsFlow {
         ApplicationDefaultCredentialsFlow { metadata_url }
     }
 
-    pub(crate) async fn token<S, T>(
+    pub(crate) async fn token<C, T>(
         &self,
-        hyper_client: &hyper_util::client::legacy::Client<S, String>,
+        hyper_client: &hyper_util::client::legacy::Client<C, String>,
         scopes: &[T],
     ) -> Result<TokenInfo, Error>
     where
         T: AsRef<str>,
-        S: Service<Uri> + Connect + Clone + Send + Sync + 'static,
-        S::Response: Connection + AsyncRead + AsyncWrite + Send + Unpin + 'static,
-        S::Future: Send + Unpin + 'static,
-        S::Error: Into<Box<dyn StdError + Send + Sync>>
+        C: Connect + Clone + Send + Sync + 'static,
     {
         let scope = crate::helper::join(scopes, ",");
         let token_uri = format!("{}?scopes={}", self.metadata_url, scope);
-        let request = hyper::Request::get(token_uri)
+        let request = http::Request::get(token_uri)
             .header("Metadata-Flavor", "Google")
-            .body(String::new())
+            .body(String::new()) // why body is needed?
             .unwrap();
         log::debug!("requesting token from metadata server: {:?}", request);
-        let (head, body) = hyper_client.request(request).await.map_err(|err| Error::OtherError(err.into()))?.into_parts();
+        let (head, body) = hyper_client.request(request).await?.into_parts();
         let body = body.collect().await?.to_bytes();
         log::debug!("received response; head: {:?}, body: {:?}", head, body);
         TokenInfo::from_json(&body)

src/authenticator.rs

@@ -20,28 +20,24 @@ use private::AuthFlow;
 use crate::access_token::AccessTokenFlow;
 
 use futures::lock::Mutex;
-use http::Uri;
-use hyper_util::client::legacy::connect::Connection;
+use hyper_util::client::legacy::connect::Connect;
 use std::borrow::Cow;
-use std::error::Error as StdError;
 use std::fmt;
 use std::io;
 use std::path::PathBuf;
 use std::sync::Arc;
-use tokio::io::{AsyncRead, AsyncWrite};
-use tower_service::Service;
 
-struct InnerAuthenticator<S> {
-    hyper_client: hyper_util::client::legacy::Client<S, String>,
+struct InnerAuthenticator<C> {
+    hyper_client: hyper_util::client::legacy::Client<C, String>,
     storage: Storage,
     auth_flow: AuthFlow,
 }
 
 /// Authenticator is responsible for fetching tokens, handling refreshing tokens,
 /// and optionally persisting tokens to disk.
 #[derive(Clone)]
-pub struct Authenticator<S> {
-    inner: Arc<InnerAuthenticator<S>>,
+pub struct Authenticator<C> {
+    inner: Arc<InnerAuthenticator<C>>,
 }
 
 struct DisplayScopes<'a, T>(&'a [T]);
@@ -63,12 +59,9 @@ where
     }
 }
 
-impl<S> Authenticator<S>
+impl<C> Authenticator<C>
 where
-    S: Service<Uri> + Clone + Send + Sync + 'static,
-    S::Response: Connection + AsyncRead + AsyncWrite + Send + Unpin + 'static,
-    S::Future: Send + Unpin + 'static,
-    S::Error: Into<Box<dyn StdError + Send + Sync>>,
+    C: Connect + Clone + Send + Sync + 'static,
 {
     /// Return the current token for the provided scopes.
     pub async fn token<'a, T>(&'a self, scopes: &'a [T]) -> Result<AccessToken, Error>
@@ -544,7 +537,7 @@ impl ServiceAccountImpersonationAuthenticator {
 /// ```
 /// # #[cfg(any(feature = "hyper-rustls", feature = "hyper-tls"))]
 /// # async fn foo() {
-/// # let custom_hyper_client = hyper_util::client::legacy::Client::new();
+/// # let custom_hyper_client = hyper_util::client::legacy::Client::builder(hyper_util::rt::TokioExecutor::new()).build_http::<String>();
 /// # let app_secret = yup_oauth2::read_application_secret("/tmp/foo").await.unwrap();
 ///     let authenticator = yup_oauth2::DeviceFlowAuthenticator::builder(app_secret)
 ///         .hyper_client(custom_hyper_client)
@@ -604,10 +597,10 @@ impl<C, F> AuthenticatorBuilder<C, F> {
     }
 
     /// Use the provided hyper client.
-    pub fn hyper_client<NewC, B: hyper::body::Body>(
+    pub fn hyper_client<NewC>(
         self,
-        hyper_client: hyper_util::client::legacy::Client<NewC, B>,
-    ) -> AuthenticatorBuilder<hyper_util::client::legacy::Client<NewC, B>, F> {
+        hyper_client: hyper_util::client::legacy::Client<NewC, String>,
+    ) -> AuthenticatorBuilder<hyper_util::client::legacy::Client<NewC, String>, F> {
         AuthenticatorBuilder {
             hyper_client_builder: hyper_client,
             storage_type: self.storage_type,
@@ -874,7 +867,7 @@ impl<C> AuthenticatorBuilder<C, AccessTokenFlow> {
 mod private {
     use crate::access_token::AccessTokenFlow;
     use crate::application_default_credentials::ApplicationDefaultCredentialsFlow;
-    use crate::authenticator::{AsyncRead, AsyncWrite, Connection, Service, StdError, Uri};
+    use crate::authenticator::Connect;
     use crate::authorized_user::AuthorizedUserFlow;
     use crate::device::DeviceFlow;
     use crate::error::Error;
@@ -912,17 +905,14 @@ mod private {
             }
         }
 
-        pub(crate) async fn token<'a, S, T>(
+        pub(crate) async fn token<'a, C, T>(
             &'a self,
-            hyper_client: &'a hyper_util::client::legacy::Client<S, String>,
+            hyper_client: &'a hyper_util::client::legacy::Client<C, String>,
             scopes: &'a [T],
         ) -> Result<TokenInfo, Error>
         where
             T: AsRef<str>,
-            S: Service<Uri> + hyper_util::client::legacy::connect::Connect + Clone + Send + Sync + 'static,
-            S::Response: Connection + AsyncRead + AsyncWrite + Send + Unpin + 'static,
-            S::Future: Send + Unpin + 'static,
-            S::Error: Into<Box<dyn StdError + Send + Sync>>,
+            C: Connect + Clone + Send + Sync + 'static,
         {
             match self {
                 AuthFlow::DeviceFlow(device_flow) => device_flow.token(hyper_client, scopes).await,
@@ -958,14 +948,17 @@ mod private {
 /// A trait implemented for any hyper_util::client::legacy::Client as well as the DefaultHyperClient.
 pub trait HyperClientBuilder {
     /// The hyper connector that the resulting hyper client will use.
-    type Connector: Service<Uri> + Clone + Send + Sync + 'static;
+    type Connector: Connect + Clone + Send + Sync + 'static;
 
-    /// Create a hyper_util::client::legacy::Client
-    fn build_hyper_client(self) -> Result<hyper_util::client::legacy::Client<Self::Connector, String>, Error>;
+    /// Create a hyper::Client
+    fn build_hyper_client(
+        self,
+    ) -> Result<hyper_util::client::legacy::Client<Self::Connector, String>, Error>;
 
     /// Create a `hyper_util::client::legacy::Client` for tests (HTTPS not required)
     #[doc(hidden)]
-    fn build_test_hyper_client(self) -> hyper_util::client::legacy::Client<Self::Connector, String>;
+    fn build_test_hyper_client(self)
+        -> hyper_util::client::legacy::Client<Self::Connector, String>;
 }
 
 #[cfg(feature = "hyper-rustls")]
@@ -984,7 +977,7 @@ pub type DefaultAuthenticator =
 )]
 /// Default authenticator type
 pub type DefaultAuthenticator =
-    Authenticator<hyper_tls::HttpsConnector<hyper::client::HttpConnector>>;
+    Authenticator<hyper_tls::HttpsConnector<hyper_util::client::legacy::connect::HttpConnector>>;
 
 /// The builder value used when the default hyper client should be used.
 #[cfg(any(feature = "hyper-rustls", feature = "hyper-tls"))]
@@ -1001,11 +994,14 @@ pub struct DefaultHyperClient;
 )]
 impl HyperClientBuilder for DefaultHyperClient {
     #[cfg(feature = "hyper-rustls")]
-    type Connector = hyper_rustls::HttpsConnector<hyper_util::client::legacy::connect::HttpConnector>;
+    type Connector =
+        hyper_rustls::HttpsConnector<hyper_util::client::legacy::connect::HttpConnector>;
     #[cfg(all(not(feature = "hyper-rustls"), feature = "hyper-tls"))]
     type Connector = hyper_tls::HttpsConnector<hyper_util::client::legacy::connect::HttpConnector>;
 
-    fn build_hyper_client(self) -> Result<hyper_util::client::legacy::Client<Self::Connector, String>, Error> {
+    fn build_hyper_client(
+        self,
+    ) -> Result<hyper_util::client::legacy::Client<Self::Connector, String>, Error> {
         #[cfg(feature = "hyper-rustls")]
         let connector = hyper_rustls::HttpsConnectorBuilder::new()
             .with_native_roots()?
@@ -1016,12 +1012,16 @@ impl HyperClientBuilder for DefaultHyperClient {
         #[cfg(all(not(feature = "hyper-rustls"), feature = "hyper-tls"))]
         let connector = hyper_tls::HttpsConnector::new();
 
-        Ok(hyper_util::client::legacy::Client::builder(hyper_util::rt::TokioExecutor::new())
-            .pool_max_idle_per_host(0)
-            .build::<_, _>(connector))
+        Ok(
+            hyper_util::client::legacy::Client::builder(hyper_util::rt::TokioExecutor::new())
+                .pool_max_idle_per_host(0)
+                .build::<_, String>(connector),
+        )
     }
 
-    fn build_test_hyper_client(self) -> hyper_util::client::legacy::Client<Self::Connector, String> {
+    fn build_test_hyper_client(
+        self,
+    ) -> hyper_util::client::legacy::Client<Self::Connector, String> {
         #[cfg(feature = "hyper-rustls")]
         let connector = hyper_rustls::HttpsConnectorBuilder::new()
             .with_native_roots()
@@ -1035,24 +1035,23 @@ impl HyperClientBuilder for DefaultHyperClient {
 
         hyper_util::client::legacy::Client::builder(hyper_util::rt::TokioExecutor::new())
             .pool_max_idle_per_host(0)
-            .build::<_, _>(connector)
+            .build::<_, String>(connector)
     }
 }
 
-impl<S> HyperClientBuilder for hyper_util::client::legacy::Client<S, String>
+impl<C> HyperClientBuilder for hyper_util::client::legacy::Client<C, String>
 where
-    S: Service<Uri> + Clone + Send + Sync + 'static,
-    S::Response: Connection + AsyncRead + AsyncWrite + Send + Unpin + 'static,
-    S::Future: Send + Unpin + 'static,
-    S::Error: Into<Box<dyn StdError + Send + Sync>>,
+    C: Connect + Clone + Send + Sync + 'static,
 {
-    type Connector = S;
+    type Connector = C;
 
-    fn build_hyper_client(self) -> Result<hyper_util::client::legacy::Client<S, String>, Error> {
+    fn build_hyper_client(self) -> Result<hyper_util::client::legacy::Client<C, String>, Error> {
         Ok(self)
     }
 
-    fn build_test_hyper_client(self) -> hyper_util::client::legacy::Client<Self::Connector, String> {
+    fn build_test_hyper_client(
+        self,
+    ) -> hyper_util::client::legacy::Client<Self::Connector, String> {
         self
     }
 }