refactor: restructure and reuse code

Author: sivizius

Cargo.toml

@@ -31,7 +31,7 @@ smol-hyper = { version = "0.1.1", optional = true, default-features = false, fea
     "async-io",
 ] }
 futures-lite = { version = "2.6.0", optional = true }
-# vsock sockets
+# VSOCK sockets
 vsock = { version = "0.5.1", optional = true }
 
 [dev-dependencies]

README.md

@@ -1,12 +1,12 @@
 ## Hyper Client Sockets
 
-Before hyper v1, hyperlocal was the most convenient solution to use Unix sockets for both client and server. With hyper v1, server socket support is no longer needed (just use `UnixListener` or `VsockListener` instead of `TcpListener`), yet hyperlocal still has it and hasn't received a release since several years.
+Before hyper v1, hyperlocal was the most convenient solution to use Unix Domain sockets for both client and server. With hyper v1, server socket support is no longer needed (just use `UnixListener` or `VsockListener` instead of `TcpListener`), yet hyperlocal still has it and hasn't received a release since several years.
 
 This library provides hyper v1 client support for:
 
 - Unix (`AF_UNIX`) sockets (`HyperUnixStream` implementing hyper traits)
 - VSock (`AF_VSOCK`) sockets (`HyperVsockStream` implementing hyper traits)
-- Firecracker Unix sockets that need `CONNECT` commands in order to establish a tunnel (`HyperFirecrackerStream` implementing hyper traits)
+- Firecracker Unix Domain sockets that need `CONNECT` commands in order to establish a tunnel (`HyperFirecrackerStream` implementing hyper traits)
 
 Additionally, the library supports different async I/O backends:
 

src/async_io.rs

@@ -0,0 +1,49 @@
+use std::{
+    io::Result,
+    ops::{Deref, DerefMut},
+    os::unix::net::UnixStream,
+    path::Path,
+};
+
+use async_io::Async;
+use futures_lite::{io::BufReader, AsyncBufReadExt as _, AsyncWriteExt as _, StreamExt as _};
+use smol_hyper::rt::FuturesIo;
+
+use crate::utils::{
+    firecracker::{format_request, parse_connection_response},
+    hyper_io_by_deref,
+};
+
+pub type AsyncFirecrackerIoInner = FuturesIo<Async<UnixStream>>;
+
+pub struct AsyncFirecrackerIo(AsyncFirecrackerIoInner);
+
+impl AsyncFirecrackerIo {
+    pub(super) async fn connect<P>(host_socket_path: P, guest_port: u32) -> Result<Self>
+    where
+        P: AsRef<Path>,
+    {
+        let mut stream = Async::<UnixStream>::connect(host_socket_path).await?;
+        stream.write_all(format_request(guest_port).as_bytes()).await?;
+        let response = BufReader::new(&mut stream).lines().next().await.transpose();
+        parse_connection_response(stream, response)
+            .map(FuturesIo::new)
+            .map(Self)
+    }
+}
+
+impl Deref for AsyncFirecrackerIo {
+    type Target = AsyncFirecrackerIoInner;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for AsyncFirecrackerIo {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+hyper_io_by_deref!(AsyncFirecrackerIo);

src/async_io/firecracker.rs

@@ -0,0 +1,70 @@
+#[cfg(feature = "firecracker")]
+#[cfg_attr(docsrs, doc(cfg(feature = "firecracker")))]
+pub mod firecracker;
+
+#[cfg(feature = "unix")]
+#[cfg_attr(docsrs, doc(cfg(feature = "unix")))]
+pub mod unix;
+
+#[cfg(feature = "vsock")]
+#[cfg_attr(docsrs, doc(cfg(feature = "vsock")))]
+pub mod vsock;
+
+#[cfg(any(feature = "firecracker", feature = "unix", feature = "vsock"))]
+use std::io::Result;
+
+#[cfg(any(feature = "firecracker", feature = "unix"))]
+use std::path::Path;
+
+#[cfg(feature = "vsock")]
+use ::vsock::VsockAddr;
+
+#[cfg(feature = "firecracker")]
+#[cfg_attr(docsrs, doc(cfg(feature = "firecracker")))]
+pub use self::firecracker::{AsyncFirecrackerIo, AsyncFirecrackerIoInner};
+
+#[cfg(feature = "unix")]
+#[cfg_attr(docsrs, doc(cfg(feature = "unix")))]
+pub use self::unix::{AsyncUnixIo, AsyncUnixIoInner};
+
+#[cfg(feature = "vsock")]
+#[cfg_attr(docsrs, doc(cfg(feature = "vsock")))]
+pub use self::vsock::{AsyncVsockIo, AsyncVsockIoInner};
+
+use crate::Backend;
+
+/// [`Backend`] for hyper-client-sockets that is implemented via the async-io crate's reactor.
+#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct AsyncIoBackend;
+
+impl Backend for AsyncIoBackend {
+    #[cfg(feature = "firecracker")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "firecracker")))]
+    type FirecrackerIo = AsyncFirecrackerIo;
+
+    #[cfg(feature = "unix")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "unix")))]
+    type UnixIo = AsyncUnixIo;
+
+    #[cfg(feature = "vsock")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "vsock")))]
+    type VsockIo = AsyncVsockIo;
+
+    #[cfg(feature = "firecracker")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "firecracker")))]
+    async fn connect_to_firecracker_socket(host_socket_path: &Path, guest_port: u32) -> Result<Self::FirecrackerIo> {
+        Self::FirecrackerIo::connect(host_socket_path, guest_port).await
+    }
+
+    #[cfg(feature = "unix")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "unix")))]
+    async fn connect_to_unix_socket(socket_path: &Path) -> Result<Self::UnixIo> {
+        Self::UnixIo::connect(socket_path).await
+    }
+
+    #[cfg(feature = "vsock")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "vsock")))]
+    async fn connect_to_vsock_socket(addr: VsockAddr) -> Result<Self::VsockIo> {
+        Self::VsockIo::connect(addr).await
+    }
+}