Begin work on sync...

src/tls_util.rs

@@ -1,17 +1,17 @@
-use std::{fs, io};
-use core::task::{Poll, Context};
+use core::future::Future;
+use core::task::{Context, Poll};
 use std::pin::Pin;
 use std::sync::Arc;
-use core::future::Future;
+use std::{fs, io};
 
 use futures_util::future::*;
-use tokio::io::{AsyncRead, AsyncWrite};
-use rustls::internal::pemfile;
-use hyper::client::HttpConnector;
 use hyper::client::connect::Connection;
+use hyper::client::HttpConnector;
 use hyper::service::Service;
 use hyper::Uri;
 use hyper_rustls::MaybeHttpsStream;
+use rustls::internal::pemfile;
+use tokio::io::{AsyncRead, AsyncWrite};
 use tokio_rustls::TlsConnector;
 use webpki::DNSNameRef;
 
@@ -58,7 +58,6 @@ pub fn load_private_key(filename: &str) -> Result<rustls::PrivateKey, Error> {
 	Ok(keys[0].clone())
 }
 
-
 // ---- AWFUL COPYPASTA FROM HYPER-RUSTLS connector.rs
 // ---- ALWAYS USE `garage` AS HOSTNAME FOR TLS VERIFICATION
 
@@ -85,56 +84,56 @@ impl HttpsConnectorFixedDnsname<HttpConnector> {
 }
 
 impl<T> Service<Uri> for HttpsConnectorFixedDnsname<T>
-	where
+where
 	T: Service<Uri>,
 	T::Response: Connection + AsyncRead + AsyncWrite + Send + Unpin + 'static,
 	T::Future: Send + 'static,
 	T::Error: Into<BoxError>,
 {
-    type Response = MaybeHttpsStream<T::Response>;
-    type Error = BoxError;
+	type Response = MaybeHttpsStream<T::Response>;
+	type Error = BoxError;
 
-    #[allow(clippy::type_complexity)]
-    type Future =
-        Pin<Box<dyn Future<Output = Result<MaybeHttpsStream<T::Response>, BoxError>> + Send>>;
+	#[allow(clippy::type_complexity)]
+	type Future =
+		Pin<Box<dyn Future<Output = Result<MaybeHttpsStream<T::Response>, BoxError>> + Send>>;
 
-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        match self.http.poll_ready(cx) {
-            Poll::Ready(Ok(())) => Poll::Ready(Ok(())),
-            Poll::Ready(Err(e)) => Poll::Ready(Err(e.into())),
-            Poll::Pending => Poll::Pending,
-        }
-    }
+	fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+		match self.http.poll_ready(cx) {
+			Poll::Ready(Ok(())) => Poll::Ready(Ok(())),
+			Poll::Ready(Err(e)) => Poll::Ready(Err(e.into())),
+			Poll::Pending => Poll::Pending,
+		}
+	}
 
-    fn call(&mut self, dst: Uri) -> Self::Future {
-        let is_https = dst.scheme_str() == Some("https");
+	fn call(&mut self, dst: Uri) -> Self::Future {
+		let is_https = dst.scheme_str() == Some("https");
 
-        if !is_https {
-            let connecting_future = self.http.call(dst);
+		if !is_https {
+			let connecting_future = self.http.call(dst);
 
-            let f = async move {
-                let tcp = connecting_future.await.map_err(Into::into)?;
+			let f = async move {
+				let tcp = connecting_future.await.map_err(Into::into)?;
 
-                Ok(MaybeHttpsStream::Http(tcp))
-            };
-            f.boxed()
-        } else {
-            let cfg = self.tls_config.clone();
-            let connecting_future = self.http.call(dst);
+				Ok(MaybeHttpsStream::Http(tcp))
+			};
+			f.boxed()
+		} else {
+			let cfg = self.tls_config.clone();
+			let connecting_future = self.http.call(dst);
 
-			let dnsname = DNSNameRef::try_from_ascii_str(self.fixed_dnsname)
-				.expect("Invalid fixed dnsname");
+			let dnsname =
+				DNSNameRef::try_from_ascii_str(self.fixed_dnsname).expect("Invalid fixed dnsname");
 
-            let f = async move {
-                let tcp = connecting_future.await.map_err(Into::into)?;
-                let connector = TlsConnector::from(cfg);
-                let tls = connector
-                    .connect(dnsname, tcp)
-                    .await
-                    .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
-                Ok(MaybeHttpsStream::Https(tls))
-            };
-            f.boxed()
-        }
-    }
+			let f = async move {
+				let tcp = connecting_future.await.map_err(Into::into)?;
+				let connector = TlsConnector::from(cfg);
+				let tls = connector
+					.connect(dnsname, tcp)
+					.await
+					.map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
+				Ok(MaybeHttpsStream::Https(tls))
+			};
+			f.boxed()
+		}
+	}
 }