fix: export delgeate async write

Author: conblem

src/api/proxy.rs

@@ -3,7 +3,6 @@ use futures_util::{ready, TryStreamExt};
 use ppp::error::ParseError;
 use ppp::model::{Addresses, Header};
 use std::future::Future;
-use std::io::IoSlice;
 use std::net::{SocketAddr, SocketAddrV4, SocketAddrV6};
 use std::pin::Pin;
 use std::task::{Context, Poll};
@@ -120,33 +119,7 @@ impl<T> AsyncWrite for ProxyStream<T>
 where
     T: AsyncWrite + Unpin,
 {
-    fn poll_write(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &[u8],
-    ) -> Poll<IoResult<usize>> {
-        Pin::new(&mut self.stream).poll_write(cx, buf)
-    }
-
-    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<IoResult<()>> {
-        Pin::new(&mut self.stream).poll_flush(cx)
-    }
-
-    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<IoResult<()>> {
-        Pin::new(&mut self.stream).poll_shutdown(cx)
-    }
-
-    fn poll_write_vectored(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        bufs: &[IoSlice<'_>],
-    ) -> Poll<IoResult<usize>> {
-        Pin::new(&mut self.stream).poll_write_vectored(cx, bufs)
-    }
-
-    fn is_write_vectored(&self) -> bool {
-        self.stream.is_write_vectored()
-    }
+    delegate_async_write!(stream);
 }
 
 struct RealAddrFuture<'a, T> {
@@ -239,12 +212,10 @@ where
 
 #[cfg(test)]
 mod tests {
-    use futures_util::future;
     use ppp::model::{Addresses, Command, Header, Protocol, Version};
-    use std::io::{Error as IoError, ErrorKind, IoSlice, Result as IoResult};
+    use std::io::{Error as IoError, ErrorKind, Result as IoResult};
     use std::net::SocketAddr;
-    use std::pin::Pin;
-    use tokio::io::{AsyncReadExt, AsyncWrite, AsyncWriteExt};
+    use tokio::io::AsyncReadExt;
     use tokio_test::io::Builder;
 
     use super::{format_header, RemoteAddr, ToProxyStream};
@@ -354,28 +325,4 @@ mod tests {
         let actual = proxy_stream.remote_addr().unwrap();
         assert_eq!(SocketAddr::from(([1, 1, 1, 1], 443)), actual)
     }
-
-    #[tokio::test]
-    async fn test_async_write_delegation() {
-        let mut builder = Builder::new();
-        builder.write("Test1".as_ref());
-        builder.write("Test2".as_ref());
-
-        let mut proxy_stream = builder.build().source(ProxyProtocol::Disabled);
-        assert_eq!(false, proxy_stream.is_write_vectored());
-
-        proxy_stream.write_all("Test1".as_ref()).await.unwrap();
-
-        let slice = IoSlice::new("Test2".as_ref());
-        let size = future::poll_fn(move |cx| {
-            Pin::new(&mut proxy_stream).poll_write_vectored(cx, &[slice])
-        })
-        .await
-        .unwrap();
-        assert_eq!(5, size);
-
-        let mut proxy_stream = Builder::new().build().source(ProxyProtocol::Disabled);
-        assert_eq!((), proxy_stream.flush().await.unwrap());
-        assert_eq!((), proxy_stream.shutdown().await.unwrap());
-    }
 }

src/api/tls.rs

@@ -102,3 +102,15 @@ impl Acceptor {
         Ok(TlsAcceptor::from(server_config))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::io::Cursor;
+    use tokio::io::split;
+
+    #[tokio::test]
+    async fn test() {
+        let (_client_read, _server_write) = split(Cursor::new(vec![]));
+        let (_server_read, _client_write) = split(Cursor::new(vec![]));
+    }
+}

src/main.rs

@@ -14,13 +14,14 @@ use acme::DatabasePersist;
 use cert::CertManager;
 use dns::{DatabaseAuthority, DNS};
 
+#[macro_use]
+mod util;
 mod acme;
 mod api;
 mod cert;
 mod config;
 mod dns;
 mod domain;
-mod util;
 
 static MIGRATOR: Migrator = sqlx::migrate!("migrations/postgres");
 

src/util.rs

@@ -32,13 +32,56 @@ pub(crate) fn uuid() -> String {
     Uuid::new_v4().to_simple().to_string()
 }
 
+macro_rules! delegate_async_write {
+    ($item:ident) => {
+        fn poll_write(
+            mut self: ::std::pin::Pin<&mut Self>,
+            cx: &mut ::std::task::Context<'_>,
+            buf: &[::std::primitive::u8],
+        ) -> ::std::task::Poll<::std::io::Result<usize>> {
+            ::std::pin::Pin::new(&mut self.$item).poll_write(cx, buf)
+        }
+
+        fn poll_flush(
+            mut self: ::std::pin::Pin<&mut Self>,
+            cx: &mut ::std::task::Context<'_>,
+        ) -> ::std::task::Poll<::std::io::Result<()>> {
+            ::std::pin::Pin::new(&mut self.$item).poll_flush(cx)
+        }
+
+        fn poll_shutdown(
+            mut self: ::std::pin::Pin<&mut Self>,
+            cx: &mut ::std::task::Context<'_>,
+        ) -> ::std::task::Poll<::std::io::Result<()>> {
+            ::std::pin::Pin::new(&mut self.$item).poll_shutdown(cx)
+        }
+
+        fn poll_write_vectored(
+            mut self: ::std::pin::Pin<&mut Self>,
+            cx: &mut ::std::task::Context<'_>,
+            bufs: &[::std::io::IoSlice<'_>],
+        ) -> ::std::task::Poll<::std::io::Result<::std::primitive::usize>> {
+            ::std::pin::Pin::new(&mut self.$item).poll_write_vectored(cx, bufs)
+        }
+
+        fn is_write_vectored(&self) -> ::std::primitive::bool {
+            self.$item.is_write_vectored()
+        }
+    };
+}
+
 #[cfg(test)]
 mod tests {
-    use super::{error, now, to_i64, to_u64, uuid};
     use anyhow::anyhow;
-    use std::io::{Error as IoError, ErrorKind};
+    use futures_util::future;
+    use std::io::{Error as IoError, ErrorKind, IoSlice};
+    use std::pin::Pin;
     use std::thread;
     use std::time::Duration;
+    use tokio::io::{AsyncWrite, AsyncWriteExt};
+    use tokio_test::io::Builder;
+
+    use super::{error, now, to_i64, to_u64, uuid};
 
     const NUMBER_1: u64 = 2323;
     const NUMBER_2: u64 = 940329402394;
@@ -102,4 +145,39 @@ mod tests {
         let actual = actual.into_inner().expect("Error has no inner error");
         assert_eq!(format!("{}", expected), format!("{}", actual));
     }
+
+    struct Wrapper<T> {
+        inner: T,
+    }
+
+    impl<T: AsyncWrite + Unpin> AsyncWrite for Wrapper<T> {
+        delegate_async_write!(inner);
+    }
+
+    #[tokio::test]
+    async fn delegate_async_write_works() {
+        let mut builder = Builder::new();
+        builder.write("Test1".as_ref());
+        builder.write("Test2".as_ref());
+
+        let mut stream = Wrapper {
+            inner: builder.build(),
+        };
+        assert_eq!(false, stream.is_write_vectored());
+
+        stream.write_all("Test1".as_ref()).await.unwrap();
+
+        let slice = IoSlice::new("Test2".as_ref());
+        let size =
+            future::poll_fn(move |cx| Pin::new(&mut stream).poll_write_vectored(cx, &[slice]))
+                .await
+                .unwrap();
+        assert_eq!(5, size);
+
+        let mut stream = Wrapper {
+            inner: Builder::new().build(),
+        };
+        assert_eq!((), stream.flush().await.unwrap());
+        assert_eq!((), stream.shutdown().await.unwrap());
+    }
 }