fix: refactor

Author: conblem

src/api/mod.rs

@@ -60,11 +60,13 @@ where
             None => break,
         };
 
-        TCP_TOTAL_CONNECTION_COUNTER.with_label_values(&[endpoint]).inc();
+        TCP_TOTAL_CONNECTION_COUNTER
+            .with_label_values(&[endpoint])
+            .inc();
         let open_counter = TCP_OPEN_CONNECTION_COUNTER.with_label_values(&[endpoint]);
         open_counter.inc();
 
-        let http = http.clone();
+        let http = Arc::clone(&http);
         let service = service.clone();
 
         tokio::spawn(

src/api/proxy.rs

@@ -5,6 +5,7 @@ use ppp::model::{Addresses, Header};
 use std::future::Future;
 use std::io::IoSlice;
 use std::net::{SocketAddr, SocketAddrV4, SocketAddrV6};
+use std::ops::{Deref, DerefMut};
 use std::pin::Pin;
 use std::task::{Context, Poll};
 use tokio::io::{AsyncRead, AsyncWrite, Error as IoError, ErrorKind, ReadBuf, Result as IoResult};
@@ -21,14 +22,14 @@ pub(super) fn wrap(
     proxy: ProxyProtocol,
 ) -> impl Stream<Item = IoResult<impl Future<Output = IoResult<ProxyStream>>>> + Send {
     TcpListenerStream::new(listener)
-        .map_ok(move |stream| {
+        .map_ok(move |conn| conn.source(proxy))
+        .map_ok(|mut conn| {
             let span = Span::current();
-            span.record("remote.addr", &debug(stream.peer_addr()));
+            span.record("remote.addr", &debug(conn.peer_addr()));
             let span_clone = span.clone();
 
-            let mut conn = stream.source(proxy);
             async move {
-                match conn.proxy_peer().await {
+                match conn.real_addr().await {
                     Ok(Some(addr)) => {
                         span.record("remote.real", &display(addr));
                     }
@@ -68,8 +69,8 @@ pub(super) struct ProxyStream {
 }
 
 impl ProxyStream {
-    fn proxy_peer(&mut self) -> PeerAddrFuture<'_> {
-        PeerAddrFuture { proxy_stream: self }
+    fn real_addr(&mut self) -> RealAddrFuture<'_> {
+        RealAddrFuture { proxy_stream: self }
     }
 }
 
@@ -117,11 +118,25 @@ impl AsyncWrite for ProxyStream {
     }
 }
 
-struct PeerAddrFuture<'a> {
+impl Deref for ProxyStream {
+    type Target = TcpStream;
+
+    fn deref(&self) -> &Self::Target {
+        &self.stream
+    }
+}
+
+impl DerefMut for ProxyStream {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.stream
+    }
+}
+
+struct RealAddrFuture<'a> {
     proxy_stream: &'a mut ProxyStream,
 }
 
-impl<'a> PeerAddrFuture<'a> {
+impl<'a> RealAddrFuture<'a> {
     fn format_header(&self, res: Header) -> Poll<<Self as Future>::Output> {
         let addr = match res.addresses {
             Addresses::IPv4 {
@@ -175,7 +190,7 @@ impl<'a> PeerAddrFuture<'a> {
     }
 }
 
-impl Future for PeerAddrFuture<'_> {
+impl Future for RealAddrFuture<'_> {
     type Output = IoResult<Option<SocketAddr>>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

src/api/tls.rs

@@ -54,9 +54,9 @@ impl Acceptor {
         })
     }
 
-    fn create_server_config(db_cert: &Cert) -> Result<Arc<ServerConfig>> {
+    fn create_server_config(&self, db_cert: &Cert) -> Result<Arc<ServerConfig>> {
         let (private, cert) = match (&db_cert.private, &db_cert.cert) {
-            (Some(ref private), Some(ref cert)) => (private, cert),
+            (Some(private), Some(cert)) => (private, cert),
             _ => return Err(anyhow!("Cert has no Cert or Private")),
         };
 
@@ -88,10 +88,10 @@ impl Acceptor {
         };
         info!(timestamp = to_u64(&db_cert.update), "Found new cert");
 
-        let server_config = match Acceptor::create_server_config(&db_cert) {
+        let server_config = match self.create_server_config(&db_cert) {
             Ok(server_config) => server_config,
             Err(e) => {
-                error!("{:?}", e);
+                error!("{}", e);
                 let (_, server_config) = &*self.config.read();
                 return Ok(TlsAcceptor::from(Arc::clone(server_config)));
             }

src/util.rs

@@ -1,4 +1,5 @@
-use std::io;
+use anyhow::Error;
+use std::io::{Error as IoError, ErrorKind};
 use std::time::{SystemTime, UNIX_EPOCH};
 use uuid::Uuid;
 
@@ -17,11 +18,11 @@ pub(crate) fn now() -> u64 {
         .as_secs()
 }
 
-pub(crate) fn error<E: From<io::Error>>(err: impl Into<anyhow::Error>) -> E {
+pub(crate) fn error<I: Into<Error>, E: From<IoError>>(err: I) -> E {
     let err = err.into();
-    let err = match err.downcast::<io::Error>() {
+    let err = match err.downcast::<IoError>() {
         Ok(err) => err,
-        Err(err) => io::Error::new(io::ErrorKind::Other, err),
+        Err(err) => IoError::new(ErrorKind::Other, err),
     };
 
     E::from(err)
@@ -63,8 +64,8 @@ mod tests {
 
     #[test]
     fn io_error_works() {
-        let expected = io::Error::new(io::ErrorKind::InvalidData, anyhow!("Hallo"));
-        let err = io::Error::new(io::ErrorKind::InvalidData, anyhow!("Hallo"));
+        let expected = IoError::new(ErrorKind::InvalidData, "Hallo");
+        let err = IoError::new(ErrorKind::InvalidData, "Hallo");
 
         let actual = match error(err) {
             acme_lib::Error::Io(err) => err,
@@ -83,9 +84,9 @@ mod tests {
             _ => panic!("Cannot match err"),
         };
 
-        assert_eq!(io::ErrorKind::Other, actual.kind());
+        assert_eq!(ErrorKind::Other, actual.kind());
 
-        // is not equal as original error gast boxed by io error
+        // is not equal because original error gets boxed in an io error
         assert_ne!(format!("{:?}", expected), format!("{:?}", actual));
 
         // here we access the actual inner error