feat(tokio,async_io,connector): expose inner types

Author: sivizius

src/async_io/firecracker.rs

@@ -16,7 +16,8 @@ use crate::utils::{
 
 pub type AsyncFirecrackerIoInner = FuturesIo<Async<UnixStream>>;
 
-pub struct AsyncFirecrackerIo(AsyncFirecrackerIoInner);
+#[derive(Debug)]
+pub struct AsyncFirecrackerIo(pub AsyncFirecrackerIoInner);
 
 impl AsyncFirecrackerIo {
     pub(super) async fn connect<P>(host_socket_path: P, guest_port: u32) -> Result<Self>
@@ -46,4 +47,16 @@ impl DerefMut for AsyncFirecrackerIo {
     }
 }
 
+impl From<AsyncFirecrackerIoInner> for AsyncFirecrackerIo {
+    fn from(inner: AsyncFirecrackerIoInner) -> Self {
+        Self(inner)
+    }
+}
+
+impl From<AsyncFirecrackerIo> for AsyncFirecrackerIoInner {
+    fn from(AsyncFirecrackerIo(inner): AsyncFirecrackerIo) -> Self {
+        inner
+    }
+}
+
 hyper_io_by_deref!(AsyncFirecrackerIo);

src/async_io/unix.rs

@@ -12,7 +12,8 @@ use crate::utils::hyper_io_by_deref;
 
 pub type AsyncUnixIoInner = FuturesIo<Async<UnixStream>>;
 
-pub struct AsyncUnixIo(AsyncUnixIoInner);
+#[derive(Debug)]
+pub struct AsyncUnixIo(pub AsyncUnixIoInner);
 
 impl AsyncUnixIo {
     pub(super) async fn connect<P>(socket_path: P) -> Result<Self>
@@ -40,4 +41,16 @@ impl DerefMut for AsyncUnixIo {
     }
 }
 
+impl From<AsyncUnixIoInner> for AsyncUnixIo {
+    fn from(inner: AsyncUnixIoInner) -> Self {
+        Self(inner)
+    }
+}
+
+impl From<AsyncUnixIo> for AsyncUnixIoInner {
+    fn from(AsyncUnixIo(inner): AsyncUnixIo) -> Self {
+        inner
+    }
+}
+
 hyper_io_by_deref!(AsyncUnixIo);

src/async_io/vsock.rs

@@ -16,7 +16,8 @@ use crate::utils::vsock::{check_connection, raw_connect, try_advance_cursor, try
 
 pub type AsyncVsockIoInner = Async<File>;
 
-pub struct AsyncVsockIo(AsyncVsockIoInner);
+#[derive(Debug)]
+pub struct AsyncVsockIo(pub AsyncVsockIoInner);
 
 impl AsyncVsockIo {
     pub(super) async fn connect(addr: VsockAddr) -> Result<Self> {
@@ -78,6 +79,18 @@ impl DerefMut for AsyncVsockIo {
     }
 }
 
+impl From<AsyncVsockIoInner> for AsyncVsockIo {
+    fn from(inner: AsyncVsockIoInner) -> Self {
+        Self(inner)
+    }
+}
+
+impl From<AsyncVsockIo> for AsyncVsockIoInner {
+    fn from(AsyncVsockIo(inner): AsyncVsockIo) -> Self {
+        inner
+    }
+}
+
 impl Read for AsyncVsockIo {
     #[inline(always)]
     fn poll_read(

src/connector/mod.rs

@@ -33,7 +33,27 @@ pub use self::vsock::VsockConnector;
 
 /// This is an internal wrapper over an IO type that implements [`Write`] and
 /// [`Read`] that also implements [`Connection`] to achieve compatibility with hyper-util.
-pub struct ConnectableIo<IO>(IO);
+#[derive(Debug)]
+pub struct ConnectableIo<IO>(pub IO);
+
+impl<IO> From<IO> for ConnectableIo<IO> {
+    fn from(inner: IO) -> Self {
+        Self(inner)
+    }
+}
+
+impl<IO: Write + Read + Send + Unpin> Connection for ConnectableIo<IO> {
+    fn connected(&self) -> Connected {
+        Connected::new()
+    }
+}
+
+impl<IO: Write + Read + Send + Unpin> Read for ConnectableIo<IO> {
+    #[inline(always)]
+    fn poll_read(self: Pin<&mut Self>, ctx: &mut Context<'_>, buf: ReadBufCursor<'_>) -> Poll<Result<()>> {
+        Pin::new(&mut self.get_mut().0).poll_read(ctx, buf)
+    }
+}
 
 impl<IO: Write + Read + Send + Unpin> Write for ConnectableIo<IO> {
     #[inline(always)]
@@ -61,16 +81,3 @@ impl<IO: Write + Read + Send + Unpin> Write for ConnectableIo<IO> {
         Pin::new(&mut self.get_mut().0).poll_write_vectored(ctx, bufs)
     }
 }
-
-impl<IO: Write + Read + Send + Unpin> Read for ConnectableIo<IO> {
-    #[inline(always)]
-    fn poll_read(self: Pin<&mut Self>, ctx: &mut Context<'_>, buf: ReadBufCursor<'_>) -> Poll<Result<()>> {
-        Pin::new(&mut self.get_mut().0).poll_read(ctx, buf)
-    }
-}
-
-impl<IO: Write + Read + Send + Unpin> Connection for ConnectableIo<IO> {
-    fn connected(&self) -> Connected {
-        Connected::new()
-    }
-}

src/tokio/firecracker.rs

@@ -17,7 +17,8 @@ use crate::utils::{
 
 pub type TokioFirecrackerIoInner = TokioIo<UnixStream>;
 
-pub struct TokioFirecrackerIo(TokioIo<UnixStream>);
+#[derive(Debug)]
+pub struct TokioFirecrackerIo(pub TokioIo<UnixStream>);
 
 impl TokioFirecrackerIo {
     pub(super) async fn connect<P>(host_socket_path: P, guest_port: u32) -> Result<Self>
@@ -46,4 +47,16 @@ impl DerefMut for TokioFirecrackerIo {
     }
 }
 
+impl From<TokioFirecrackerIoInner> for TokioFirecrackerIo {
+    fn from(inner: TokioFirecrackerIoInner) -> Self {
+        Self(inner)
+    }
+}
+
+impl From<TokioFirecrackerIo> for TokioFirecrackerIoInner {
+    fn from(TokioFirecrackerIo(inner): TokioFirecrackerIo) -> Self {
+        inner
+    }
+}
+
 hyper_io_by_deref!(TokioFirecrackerIo);

src/tokio/unix.rs

@@ -11,7 +11,8 @@ use crate::utils::hyper_io_by_deref;
 
 pub type TokioUnixIoInner = TokioIo<UnixStream>;
 
-pub struct TokioUnixIo(TokioUnixIoInner);
+#[derive(Debug)]
+pub struct TokioUnixIo(pub TokioUnixIoInner);
 
 impl TokioUnixIo {
     pub(super) async fn connect<P>(socket_path: P) -> Result<Self>
@@ -36,4 +37,16 @@ impl DerefMut for TokioUnixIo {
     }
 }
 
+impl From<TokioUnixIoInner> for TokioUnixIo {
+    fn from(inner: TokioUnixIoInner) -> Self {
+        Self(inner)
+    }
+}
+
+impl From<TokioUnixIo> for TokioUnixIoInner {
+    fn from(TokioUnixIo(inner): TokioUnixIo) -> Self {
+        inner
+    }
+}
+
 hyper_io_by_deref!(TokioUnixIo);

src/tokio/vsock.rs

@@ -17,7 +17,8 @@ pub type TokioVsockIoInner = AsyncFd<VsockStream>;
 
 /// IO object representing an active VSOCK connection controlled via a Tokio [`AsyncFd`].
 /// This is internally a reimplementation of a relevant part of the tokio-vsock crate.
-pub struct TokioVsockIo(TokioVsockIoInner);
+#[derive(Debug)]
+pub struct TokioVsockIo(pub TokioVsockIoInner);
 
 impl TokioVsockIo {
     pub(super) async fn connect(addr: VsockAddr) -> Result<Self> {
@@ -80,6 +81,18 @@ impl DerefMut for TokioVsockIo {
     }
 }
 
+impl From<TokioVsockIoInner> for TokioVsockIo {
+    fn from(inner: TokioVsockIoInner) -> Self {
+        Self(inner)
+    }
+}
+
+impl From<TokioVsockIo> for TokioVsockIoInner {
+    fn from(TokioVsockIo(inner): TokioVsockIo) -> Self {
+        inner
+    }
+}
+
 impl Read for TokioVsockIo {
     #[inline(always)]
     fn poll_read(