Style tweaks

src/acceptor.rs

@@ -5,10 +5,8 @@ use std::pin::Pin;
 use std::sync::Arc;
 
 use futures_util::ready;
-use hyper::server::{
-    accept::Accept,
-    conn::{AddrIncoming, AddrStream},
-};
+use hyper::server::accept::Accept;
+use hyper::server::conn::{AddrIncoming, AddrStream};
 use rustls::{ServerConfig, ServerConnection};
 use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
 

src/acceptor/builder.rs

@@ -5,6 +5,7 @@ use pki_types::{CertificateDer, PrivateKeyDer};
 use rustls::ServerConfig;
 
 use super::TlsAcceptor;
+
 /// Builder for [`TlsAcceptor`]
 pub struct AcceptorBuilder<State>(State);
 

src/connector.rs

@@ -4,7 +4,9 @@ use std::sync::Arc;
 use std::task::{Context, Poll};
 use std::{fmt, io};
 
-use hyper::{client::connect::Connection, service::Service, Uri};
+use hyper::client::connect::Connection;
+use hyper::service::Service;
+use hyper::Uri;
 use pki_types::ServerName;
 use tokio::io::{AsyncRead, AsyncWrite};
 use tokio_rustls::TlsConnector;
@@ -33,28 +35,6 @@ impl<T> HttpsConnector<T> {
     }
 }
 
-impl<T> fmt::Debug for HttpsConnector<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_struct("HttpsConnector")
-            .field("force_https", &self.force_https)
-            .finish()
-    }
-}
-
-impl<H, C> From<(H, C)> for HttpsConnector<H>
-where
-    C: Into<Arc<rustls::ClientConfig>>,
-{
-    fn from((http, cfg): (H, C)) -> Self {
-        Self {
-            force_https: false,
-            http,
-            tls_config: cfg.into(),
-            override_server_name: None,
-        }
-    }
-}
-
 impl<T> Service<Uri> for HttpsConnector<T>
 where
     T: Service<Uri>,
@@ -80,62 +60,82 @@ where
     fn call(&mut self, dst: Uri) -> Self::Future {
         // dst.scheme() would need to derive Eq to be matchable;
         // use an if cascade instead
-        if let Some(sch) = dst.scheme() {
-            if sch == &http::uri::Scheme::HTTP && !self.force_https {
-                let connecting_future = self.http.call(dst);
-
-                let f = async move {
-                    let tcp = connecting_future
-                        .await
-                        .map_err(Into::into)?;
-
-                    Ok(MaybeHttpsStream::Http(tcp))
-                };
-                Box::pin(f)
-            } else if sch == &http::uri::Scheme::HTTPS {
-                let cfg = self.tls_config.clone();
-                let mut hostname = match self.override_server_name.as_deref() {
-                    Some(h) => h,
-                    None => dst.host().unwrap_or_default(),
-                };
-
-                // Remove square brackets around IPv6 address.
-                if let Some(trimmed) = hostname
-                    .strip_prefix('[')
-                    .and_then(|h| h.strip_suffix(']'))
-                {
-                    hostname = trimmed;
-                }
-
-                let hostname = match ServerName::try_from(hostname) {
-                    Ok(dnsname) => dnsname.to_owned(),
-                    Err(_) => {
-                        let err = io::Error::new(io::ErrorKind::Other, "invalid dnsname");
-                        return Box::pin(async move { Err(Box::new(err).into()) });
-                    }
-                };
-                let connecting_future = self.http.call(dst);
-
-                let f = async move {
-                    let tcp = connecting_future
-                        .await
-                        .map_err(Into::into)?;
-                    let connector = TlsConnector::from(cfg);
-                    let tls = connector
-                        .connect(hostname, tcp)
-                        .await
-                        .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
-                    Ok(MaybeHttpsStream::Https(tls))
-                };
-                Box::pin(f)
-            } else {
-                let err =
-                    io::Error::new(io::ErrorKind::Other, format!("Unsupported scheme {}", sch));
-                Box::pin(async move { Err(err.into()) })
+        match dst.scheme() {
+            Some(scheme) if scheme == &http::uri::Scheme::HTTP => {
+                let future = self.http.call(dst);
+                return Box::pin(async move {
+                    Ok(MaybeHttpsStream::Http(future.await.map_err(Into::into)?))
+                });
+            }
+            Some(scheme) if scheme != &http::uri::Scheme::HTTPS => {
+                let message = format!("unsupported scheme {scheme}");
+                return Box::pin(async move {
+                    Err(io::Error::new(io::ErrorKind::Other, message).into())
+                });
+            }
+            Some(_) => {}
+            None => {
+                return Box::pin(async move {
+                    Err(io::Error::new(io::ErrorKind::Other, "missing scheme").into())
+                })
             }
-        } else {
-            let err = io::Error::new(io::ErrorKind::Other, "Missing scheme");
-            Box::pin(async move { Err(err.into()) })
+        };
+
+        let cfg = self.tls_config.clone();
+        let mut hostname = match self.override_server_name.as_deref() {
+            Some(h) => h,
+            None => dst.host().unwrap_or_default(),
+        };
+
+        // Remove square brackets around IPv6 address.
+        if let Some(trimmed) = hostname
+            .strip_prefix('[')
+            .and_then(|h| h.strip_suffix(']'))
+        {
+            hostname = trimmed;
         }
+
+        let hostname = match ServerName::try_from(hostname) {
+            Ok(dns_name) => dns_name.to_owned(),
+            Err(_) => {
+                let err = io::Error::new(io::ErrorKind::Other, "invalid dnsname");
+                return Box::pin(async move { Err(Box::new(err).into()) });
+            }
+        };
+
+        let connecting_future = self.http.call(dst);
+        Box::pin(async move {
+            let tcp = connecting_future
+                .await
+                .map_err(Into::into)?;
+            Ok(MaybeHttpsStream::Https(
+                TlsConnector::from(cfg)
+                    .connect(hostname, tcp)
+                    .await
+                    .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?,
+            ))
+        })
+    }
+}
+
+impl<H, C> From<(H, C)> for HttpsConnector<H>
+where
+    C: Into<Arc<rustls::ClientConfig>>,
+{
+    fn from((http, cfg): (H, C)) -> Self {
+        Self {
+            force_https: false,
+            http,
+            tls_config: cfg.into(),
+            override_server_name: None,
+        }
+    }
+}
+
+impl<T> fmt::Debug for HttpsConnector<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("HttpsConnector")
+            .field("force_https", &self.force_https)
+            .finish()
     }
 }