fix: remove unix on win (#96)

hubertshelley · web-flow · commit ad7ab58c77eb · 2025-05-15T10:35:35.000+08:00
diff --git a/silent/src/core/listener.rs b/silent/src/core/listener.rs
@@ -4,6 +4,7 @@ use crate::core::connection::Connection;
 use futures_util::StreamExt;
 use futures_util::stream::FuturesUnordered;
 use std::io::Result;
+#[cfg(not(target_os = "windows"))]
 use std::path::Path;
 use std::pin::Pin;
 #[cfg(feature = "tls")]
@@ -20,6 +21,7 @@ pub trait Listen: Send + Sync {
 
 pub enum Listener {
     TcpListener(tokio::net::TcpListener),
+    #[cfg(not(target_os = "windows"))]
     UnixListener(tokio::net::UnixListener),
 }
 
@@ -34,6 +36,7 @@ impl From<std::net::TcpListener> for Listener {
     }
 }
 
+#[cfg(not(target_os = "windows"))]
 impl From<std::os::unix::net::UnixListener> for Listener {
     fn from(value: std::os::unix::net::UnixListener) -> Self {
         Listener::UnixListener(
@@ -48,6 +51,7 @@ impl From<tokio::net::TcpListener> for Listener {
     }
 }
 
+#[cfg(not(target_os = "windows"))]
 impl From<tokio::net::UnixListener> for Listener {
     fn from(value: tokio::net::UnixListener) -> Self {
         Listener::UnixListener(value)
@@ -67,6 +71,7 @@ impl Listen for Listener {
                 };
                 Box::pin(accept_future)
             }
+            #[cfg(not(target_os = "windows"))]
             Listener::UnixListener(listener) => {
                 let accept_future = async move {
                     let (stream, addr) = listener.accept().await?;
@@ -83,6 +88,7 @@ impl Listen for Listener {
     fn local_addr(&self) -> Result<SocketAddr> {
         match self {
             Listener::TcpListener(listener) => listener.local_addr().map(SocketAddr::Tcp),
+            #[cfg(not(target_os = "windows"))]
             Listener::UnixListener(listener) => Ok(SocketAddr::Unix(listener.local_addr()?.into())),
         }
     }
@@ -150,6 +156,7 @@ impl ListenersBuilder {
         )));
     }
 
+    #[cfg(not(target_os = "windows"))]
     pub fn bind_unix<P: AsRef<Path>>(&mut self, path: P) {
         self.listeners.push(Box::new(Listener::from(
             std::os::unix::net::UnixListener::bind(path).expect("failed to bind listener"),
diff --git a/silent/src/core/socket_addr.rs b/silent/src/core/socket_addr.rs
@@ -7,6 +7,7 @@ pub enum SocketAddr {
     Tcp(std::net::SocketAddr),
     #[cfg(feature = "tls")]
     TlsTcp(std::net::SocketAddr),
+    #[cfg(not(target_os = "windows"))]
     Unix(std::os::unix::net::SocketAddr),
 }
 
@@ -26,6 +27,7 @@ impl Debug for SocketAddr {
             SocketAddr::Tcp(addr) => write!(f, "http://{}", addr),
             #[cfg(feature = "tls")]
             SocketAddr::TlsTcp(addr) => write!(f, "https://{}", addr),
+            #[cfg(not(target_os = "windows"))]
             SocketAddr::Unix(addr) => write!(f, "UnixSocketAddr({:?})", addr),
         }
     }
@@ -38,6 +40,7 @@ impl Display for SocketAddr {
             SocketAddr::Tcp(addr) => write!(f, "{}", addr),
             #[cfg(feature = "tls")]
             SocketAddr::TlsTcp(addr) => write!(f, "{}", addr),
+            #[cfg(not(target_os = "windows"))]
             SocketAddr::Unix(addr) => {
                 write!(f, "{:?}", addr.as_pathname())
             }
@@ -51,6 +54,7 @@ impl From<std::net::SocketAddr> for SocketAddr {
     }
 }
 
+#[cfg(not(target_os = "windows"))]
 impl From<std::os::unix::net::SocketAddr> for SocketAddr {
     fn from(addr: std::os::unix::net::SocketAddr) -> Self {
         SocketAddr::Unix(addr)
@@ -60,6 +64,7 @@ impl From<std::os::unix::net::SocketAddr> for SocketAddr {
 impl FromStr for SocketAddr {
     type Err = std::io::Error;
 
+    #[cfg(not(target_os = "windows"))]
     fn from_str(s: &str) -> Result<Self> {
         if let Ok(addr) = s.parse::<std::net::SocketAddr>() {
             Ok(SocketAddr::Tcp(addr))
@@ -72,19 +77,34 @@ impl FromStr for SocketAddr {
             ))
         }
     }
+    #[cfg(target_os = "windows")]
+    fn from_str(s: &str) -> Result<Self> {
+        if let Ok(addr) = s.parse::<std::net::SocketAddr>() {
+            Ok(SocketAddr::Tcp(addr))
+        } else {
+            Err(std::io::Error::new(
+                std::io::ErrorKind::InvalidInput,
+                "invalid socket address",
+            ))
+        }
+    }
 }
 
 #[cfg(test)]
 mod tests {
     use crate::core::socket_addr::SocketAddr;
-    use std::path::Path;
 
     #[test]
-    fn test_socket_addr() {
+    fn test_tcp_socket_addr() {
         let addr = std::net::SocketAddr::from(([127, 0, 0, 1], 8080));
         let socket_addr = SocketAddr::from(addr);
         assert_eq!(format!("{}", socket_addr), "127.0.0.1:8080");
+    }
 
+    #[cfg(not(target_os = "windows"))]
+    #[test]
+    fn test_unix_socket_addr() {
+        use std::path::Path;
         let _ = std::fs::remove_file("/tmp/sock");
         let addr = std::os::unix::net::SocketAddr::from_pathname("/tmp/sock").unwrap();
         let socket_addr = SocketAddr::from(addr);
diff --git a/silent/src/core/stream.rs b/silent/src/core/stream.rs
@@ -4,17 +4,21 @@ use std::io::Error;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
-use tokio::net::{TcpStream, UnixStream};
+use tokio::net::TcpStream;
+#[cfg(not(target_os = "windows"))]
+use tokio::net::UnixStream;
 
 pub enum Stream {
     TcpStream(TcpStream),
+    #[cfg(not(target_os = "windows"))]
     UnixStream(UnixStream),
 }
 
 impl Stream {
     pub fn peer_addr(&self) -> io::Result<SocketAddr> {
         match self {
             Stream::TcpStream(s) => Ok(s.peer_addr()?.into()),
+            #[cfg(not(target_os = "windows"))]
             Stream::UnixStream(s) => Ok(SocketAddr::Unix(s.peer_addr()?.into())),
         }
     }
@@ -28,6 +32,7 @@ impl AsyncRead for Stream {
     ) -> Poll<io::Result<()>> {
         match self.get_mut() {
             Stream::TcpStream(s) => Pin::new(s).poll_read(cx, buf),
+            #[cfg(not(target_os = "windows"))]
             Stream::UnixStream(s) => Pin::new(s).poll_read(cx, buf),
         }
     }
@@ -41,20 +46,23 @@ impl AsyncWrite for Stream {
     ) -> Poll<Result<usize, Error>> {
         match self.get_mut() {
             Stream::TcpStream(s) => Pin::new(s).poll_write(cx, buf),
+            #[cfg(not(target_os = "windows"))]
             Stream::UnixStream(s) => Pin::new(s).poll_write(cx, buf),
         }
     }
 
     fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Error>> {
         match self.get_mut() {
             Stream::TcpStream(s) => Pin::new(s).poll_flush(cx),
+            #[cfg(not(target_os = "windows"))]
             Stream::UnixStream(s) => Pin::new(s).poll_flush(cx),
         }
     }
 
     fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Error>> {
         match self.get_mut() {
             Stream::TcpStream(s) => Pin::new(s).poll_shutdown(cx),
+            #[cfg(not(target_os = "windows"))]
             Stream::UnixStream(s) => Pin::new(s).poll_shutdown(cx),
         }
     }
diff --git a/silent/src/service/mod.rs b/silent/src/service/mod.rs
@@ -9,6 +9,7 @@ use crate::route::RouteService;
 use crate::scheduler::{SCHEDULER, Scheduler, middleware::SchedulerMiddleware};
 use crate::service::serve::Serve;
 use std::net::SocketAddr;
+#[cfg(not(target_os = "windows"))]
 use std::path::Path;
 use tokio::signal;
 use tokio::task::JoinSet;
@@ -52,6 +53,7 @@ impl Server {
         self
     }
 
+    #[cfg(not(target_os = "windows"))]
     #[inline]
     pub fn bind_unix<P: AsRef<Path>>(mut self, path: P) -> Self {
         self.listeners_builder.bind_unix(path);

Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@ use crate::core::connection::Connection;`
`4`	`4`	`use futures_util::StreamExt;`
`5`	`5`	`use futures_util::stream::FuturesUnordered;`
`6`	`6`	`use std::io::Result;`
	`7`	`+#[cfg(not(target_os = "windows"))]`
`7`	`8`	`use std::path::Path;`
`8`	`9`	`use std::pin::Pin;`
`9`	`10`	`#[cfg(feature = "tls")]`
`@@ -20,6 +21,7 @@ pub trait Listen: Send + Sync {`
`20`	`21`
`21`	`22`	`pub enum Listener {`
`22`	`23`	`TcpListener(tokio::net::TcpListener),`
	`24`	`+ #[cfg(not(target_os = "windows"))]`
`23`	`25`	`UnixListener(tokio::net::UnixListener),`
`24`	`26`	`}`
`25`	`27`
`@@ -34,6 +36,7 @@ impl From<std::net::TcpListener> for Listener {`
`34`	`36`	`}`
`35`	`37`	`}`
`36`	`38`
	`39`	`+#[cfg(not(target_os = "windows"))]`
`37`	`40`	`impl From<std::os::unix::net::UnixListener> for Listener {`
`38`	`41`	`fn from(value: std::os::unix::net::UnixListener) -> Self {`
`39`	`42`	`Listener::UnixListener(`
`@@ -48,6 +51,7 @@ impl From<tokio::net::TcpListener> for Listener {`
`48`	`51`	`}`
`49`	`52`	`}`
`50`	`53`
	`54`	`+#[cfg(not(target_os = "windows"))]`
`51`	`55`	`impl From<tokio::net::UnixListener> for Listener {`
`52`	`56`	`fn from(value: tokio::net::UnixListener) -> Self {`
`53`	`57`	`Listener::UnixListener(value)`
`@@ -67,6 +71,7 @@ impl Listen for Listener {`
`67`	`71`	`};`
`68`	`72`	`Box::pin(accept_future)`
`69`	`73`	`}`
	`74`	`+ #[cfg(not(target_os = "windows"))]`
`70`	`75`	`Listener::UnixListener(listener) => {`
`71`	`76`	`let accept_future = async move {`
`72`	`77`	`let (stream, addr) = listener.accept().await?;`
`@@ -83,6 +88,7 @@ impl Listen for Listener {`
`83`	`88`	`fn local_addr(&self) -> Result<SocketAddr> {`
`84`	`89`	`match self {`
`85`	`90`	`Listener::TcpListener(listener) => listener.local_addr().map(SocketAddr::Tcp),`
	`91`	`+ #[cfg(not(target_os = "windows"))]`
`86`	`92`	`Listener::UnixListener(listener) => Ok(SocketAddr::Unix(listener.local_addr()?.into())),`
`87`	`93`	`}`
`88`	`94`	`}`
`@@ -150,6 +156,7 @@ impl ListenersBuilder {`
`150`	`156`	`)));`
`151`	`157`	`}`
`152`	`158`
	`159`	`+ #[cfg(not(target_os = "windows"))]`
`153`	`160`	`pub fn bind_unix<P: AsRef<Path>>(&mut self, path: P) {`
`154`	`161`	`self.listeners.push(Box::new(Listener::from(`
`155`	`162`	`std::os::unix::net::UnixListener::bind(path).expect("failed to bind listener"),`
Original file line number	Diff line number	Diff line change
`@@ -4,17 +4,21 @@ use std::io::Error;`
`4`	`4`	`use std::pin::Pin;`
`5`	`5`	`use std::task::{Context, Poll};`
`6`	`6`	`use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};`
`7`		`-use tokio::net::{TcpStream, UnixStream};`
	`7`	`+use tokio::net::TcpStream;`
	`8`	`+#[cfg(not(target_os = "windows"))]`
	`9`	`+use tokio::net::UnixStream;`
`8`	`10`
`9`	`11`	`pub enum Stream {`
`10`	`12`	`TcpStream(TcpStream),`
	`13`	`+ #[cfg(not(target_os = "windows"))]`
`11`	`14`	`UnixStream(UnixStream),`
`12`	`15`	`}`
`13`	`16`
`14`	`17`	`impl Stream {`
`15`	`18`	`pub fn peer_addr(&self) -> io::Result<SocketAddr> {`
`16`	`19`	`match self {`
`17`	`20`	`Stream::TcpStream(s) => Ok(s.peer_addr()?.into()),`
	`21`	`+ #[cfg(not(target_os = "windows"))]`
`18`	`22`	`Stream::UnixStream(s) => Ok(SocketAddr::Unix(s.peer_addr()?.into())),`
`19`	`23`	`}`
`20`	`24`	`}`
`@@ -28,6 +32,7 @@ impl AsyncRead for Stream {`
`28`	`32`	`) -> Poll<io::Result<()>> {`
`29`	`33`	`match self.get_mut() {`
`30`	`34`	`Stream::TcpStream(s) => Pin::new(s).poll_read(cx, buf),`
	`35`	`+ #[cfg(not(target_os = "windows"))]`
`31`	`36`	`Stream::UnixStream(s) => Pin::new(s).poll_read(cx, buf),`
`32`	`37`	`}`
`33`	`38`	`}`
`@@ -41,20 +46,23 @@ impl AsyncWrite for Stream {`
`41`	`46`	`) -> Poll<Result<usize, Error>> {`
`42`	`47`	`match self.get_mut() {`
`43`	`48`	`Stream::TcpStream(s) => Pin::new(s).poll_write(cx, buf),`
	`49`	`+ #[cfg(not(target_os = "windows"))]`
`44`	`50`	`Stream::UnixStream(s) => Pin::new(s).poll_write(cx, buf),`
`45`	`51`	`}`
`46`	`52`	`}`
`47`	`53`
`48`	`54`	`fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Error>> {`
`49`	`55`	`match self.get_mut() {`
`50`	`56`	`Stream::TcpStream(s) => Pin::new(s).poll_flush(cx),`
	`57`	`+ #[cfg(not(target_os = "windows"))]`
`51`	`58`	`Stream::UnixStream(s) => Pin::new(s).poll_flush(cx),`
`52`	`59`	`}`
`53`	`60`	`}`
`54`	`61`
`55`	`62`	`fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Error>> {`
`56`	`63`	`match self.get_mut() {`
`57`	`64`	`Stream::TcpStream(s) => Pin::new(s).poll_shutdown(cx),`
	`65`	`+ #[cfg(not(target_os = "windows"))]`
`58`	`66`	`Stream::UnixStream(s) => Pin::new(s).poll_shutdown(cx),`
`59`	`67`	`}`
`60`	`68`	`}`