uds pass tests

Hexilee · Hexilee · commit ec86a359040f · 2020-04-08T00:53:08.000+08:00
diff --git a/src/lib.rs b/src/lib.rs
@@ -2,11 +2,11 @@
 
 #![warn(missing_docs)]
 
-pub use stream::AsyncStream;
+pub use socket::Socket;
 pub use tokio_postgres::*;
 
+use socket::connect_socket;
 use std::io;
-use stream::connect_stream;
 use tokio_postgres::tls::{NoTls, NoTlsStream, TlsConnect};
 use tokio_postgres::{Client, Connection};
 
@@ -31,7 +31,7 @@ use tokio_postgres::{Client, Connection};
 #[inline]
 pub async fn connect(
     config: Config,
-) -> io::Result<(Client, Connection<AsyncStream, NoTlsStream>)> {
+) -> io::Result<(Client, Connection<Socket, NoTlsStream>)> {
     connect_tls(config, NoTls).await
 }
 
@@ -57,11 +57,11 @@ pub async fn connect(
 pub async fn connect_tls<T>(
     config: Config,
     tls: T,
-) -> io::Result<(Client, Connection<AsyncStream, T::Stream>)>
+) -> io::Result<(Client, Connection<Socket, T::Stream>)>
 where
-    T: TlsConnect<AsyncStream>,
+    T: TlsConnect<Socket>,
 {
-    let stream = connect_stream(&config).await?;
+    let stream = connect_socket(&config).await?;
     connect_raw(stream, config, tls).await
 }
 
@@ -88,15 +88,15 @@ pub async fn connect_raw<S, T>(
     stream: S,
     config: Config,
     tls: T,
-) -> io::Result<(Client, Connection<AsyncStream, T::Stream>)>
+) -> io::Result<(Client, Connection<Socket, T::Stream>)>
 where
-    S: Into<AsyncStream>,
-    T: TlsConnect<AsyncStream>,
+    S: Into<Socket>,
+    T: TlsConnect<Socket>,
 {
     config
         .connect_raw(stream.into(), tls)
         .await
         .map_err(|err| io::Error::new(io::ErrorKind::Other, err))
 }
 
-mod stream;
+mod socket;
diff --git a/src/socket.rs b/src/socket.rs
@@ -18,9 +18,9 @@ pub trait AsyncReadWriter: 'static + Unpin + Send + Read + Write {}
 impl<T> AsyncReadWriter for T where T: 'static + Unpin + Send + Read + Write {}
 
 /// A adaptor between futures::io::{AsyncRead, AsyncWrite} and tokio::io::{AsyncRead, AsyncWrite}.
-pub struct AsyncStream(Box<dyn AsyncReadWriter>);
+pub struct Socket(Box<dyn AsyncReadWriter>);
 
-impl<T> From<T> for AsyncStream
+impl<T> From<T> for Socket
 where
     T: AsyncReadWriter,
 {
@@ -29,7 +29,7 @@ where
     }
 }
 
-impl AsyncRead for AsyncStream {
+impl AsyncRead for Socket {
     #[inline]
     unsafe fn prepare_uninitialized_buffer(&self, _buf: &mut [MaybeUninit<u8>]) -> bool {
         false
@@ -45,7 +45,7 @@ impl AsyncRead for AsyncStream {
     }
 }
 
-impl AsyncWrite for AsyncStream {
+impl AsyncWrite for Socket {
     #[inline]
     fn poll_write(
         mut self: Pin<&mut Self>,
@@ -76,19 +76,20 @@ impl AsyncWrite for AsyncStream {
 ///
 ///
 #[inline]
-pub async fn connect_stream(config: &Config) -> io::Result<AsyncStream> {
+pub async fn connect_socket(config: &Config) -> io::Result<Socket> {
     let mut error = io::Error::new(io::ErrorKind::Other, "host missing");
     let mut ports = config.get_ports().iter().cloned();
     for host in config.get_hosts() {
+        let port = ports.next().unwrap_or(DEFAULT_PORT);
         let result = match host {
             #[cfg(unix)]
-            Host::Unix(path) => UnixStream::connect(path).await.map(Into::into),
-            Host::Tcp(tcp) => {
-                let port = ports.next().unwrap_or(DEFAULT_PORT);
-                TcpStream::connect((tcp.as_str(), port))
-                    .await
-                    .map(Into::into)
+            Host::Unix(path) => {
+                let sock = path.join(format!(".s.PGSQL.{}", port));
+                UnixStream::connect(sock).await.map(Into::into)
             }
+            Host::Tcp(tcp) => TcpStream::connect((tcp.as_str(), port))
+                .await
+                .map(Into::into),
             #[cfg(not(unix))]
             Host::Unix(_) => {
                 io::Error::new(io::ErrorKind::Other, "unix domain socket is unsupported")
diff --git a/tests/benchmark.rs b/tests/benchmark.rs
@@ -28,8 +28,8 @@ fn benchmark() -> Result<(), Box<dyn Error>> {
     println!("  - tokio_postgres on tokio runtime:");
     let elapsed = tokio_rr.block_on(tokio_postgres(&tcp_url))?;
     println!("      - tcp: {} us/q", elapsed.as_micros() / queries);
-    // let elapsed = tokio_rr.block_on(tokio_postgres(&uds_url))?;
-    // println!("      - uds: {} us/q", elapsed.as_micros() / queries);
+    let elapsed = tokio_rr.block_on(tokio_postgres(&uds_url))?;
+    println!("      - uds: {} us/q", elapsed.as_micros() / queries);
     Ok(())
 }
 
