Unix socket listener, take 2

Cargo.toml

@@ -52,6 +52,7 @@ portpicker = "0.1.0"
 serde = { version = "1.0.102", features = ["derive"] }
 criterion = "0.3.1"
 surf = { version = "2.0.0-alpha.2", default-features = false, features = ["h1-client"] }
+tempdir = "0.3.7"
 
 [[test]]
 name = "nested"

src/server.rs

@@ -316,6 +316,48 @@ impl<State: Send + Sync + 'static> Server<State> {
         Ok(())
     }
 
+    /// Asynchronously serve the app at the given address.
+    #[cfg(all(feature = "h1-server", unix))]
+    pub async fn listen_unix(self, addr: impl AsRef<async_std::path::Path>) -> io::Result<()> {
+        let listener = async_std::os::unix::net::UnixListener::bind(addr).await?;
+        let tls = false;
+        let target = if cfg!(debug_assertions) {
+            "dev"
+        } else {
+            "release"
+        };
+
+        let address = listener
+            .local_addr()
+            .ok()
+            .map(|addr| format!("unix://{:?}", addr));
+
+        log::info!("Server listening", { address: address, target: target, tls: tls });
+
+        let mut incoming = listener.incoming();
+        while let Some(stream) = incoming.next().await {
+            let stream = stream?;
+            let this = self.clone();
+            let local_addr = stream.local_addr().ok().map(|addr| format!("{:?}", addr));
+            let peer_addr = stream.peer_addr().ok().map(|addr| format!("{:?}", addr));
+            task::spawn(async move {
+                let res = async_h1::accept(stream, |mut req| async {
+                    req.set_local_addr(local_addr.as_ref());
+                    req.set_peer_addr(peer_addr.as_ref());
+                    let res = this.respond(req).await;
+                    let res = res.map_err(|_| io::Error::from(io::ErrorKind::Other))?;
+                    Ok(res)
+                })
+                .await;
+
+                if let Err(err) = res {
+                    log::error!("async-h1 error", { error: err.to_string() });
+                }
+            });
+        }
+        Ok(())
+    }
+
     /// Respond to a `Request` with a `Response`.
     ///
     /// This method is useful for testing endpoints directly,

tests/unix.rs

@@ -0,0 +1,50 @@
+#[cfg(unix)]
+mod unix_tests {
+    use async_std::os::unix::net::UnixStream;
+    use async_std::prelude::*;
+    use async_std::task;
+    use http_types::{url::Url, Method, Request, Response, StatusCode};
+    use std::time::Duration;
+    use tempdir::TempDir;
+
+    #[test]
+    fn hello_unix_world() -> Result<(), http_types::Error> {
+        task::block_on(async {
+            let tmp_dir = TempDir::new("tide").expect("Temp dir not created");
+            let sock_path = tmp_dir.path().join("sock");
+            let sock_path_for_client = sock_path.clone();
+
+            let server = task::spawn(async move {
+                let mut app = tide::new();
+                app.at("/").get(|req: tide::Request<()>| async move {
+                    let mut response = Response::new(StatusCode::Ok);
+                    response.set_body(serde_json::json!({
+                        "peer_addr": req.peer_addr().unwrap(),
+                        "local_addr": req.local_addr().unwrap()
+                    }));
+                    Ok(response)
+                });
+                app.listen_unix(sock_path).await?;
+                http_types::Result::Ok(())
+            });
+
+            let client = task::spawn(async move {
+                task::sleep(Duration::from_millis(100)).await;
+                let listener = UnixStream::connect(&sock_path_for_client).await?;
+                let request = Request::new(Method::Get, Url::parse("http://_/").unwrap());
+                let response = async_h1::connect(listener, request).await?;
+                let body: serde_json::Value = response.body_json().await.unwrap();
+                assert!(body.get("peer_addr").unwrap().is_string());
+                assert!(body
+                    .get("local_addr")
+                    .unwrap()
+                    .as_str()
+                    .unwrap()
+                    .contains(sock_path_for_client.to_str().unwrap()));
+                Ok(())
+            });
+
+            server.race(client).await
+        })
+    }
+}