remove build-in tls support

Author: Hexilee

.github/workflows/code-coverage.yml

@@ -30,18 +30,6 @@ jobs:
           - 5432:5432
         # needed because the postgres container does not provide a healthcheck
         options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
-      postgres-tls:
-        image: nimbustech/postgres-ssl:9.5
-        env:
-          POSTGRES_USER: postgres
-          POSTGRES_PASSWORD: postgres
-          POSTGRES_DB: postgres
-        ports:
-          - 5433:5432
-        volumes:
-          - tests/cert:/var/ssl
-        # needed because the postgres container does not provide a healthcheck
-        options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
     steps:
       - name: Install psql
         run: |
@@ -63,7 +51,6 @@ jobs:
           args: --out Xml --all --all-features
         env:
           TEST_URL: "postgresql://localhost/postgres?user=postgres&password=postgres"
-          TEST_TLS_URL: "postgresql://localhost:5433/postgres?user=postgres&password=postgres?sslmode=verify-ca"
       - name: Upload to codecov.io
         uses: codecov/codecov-action@v1.0.2
         with:

.github/workflows/stable-test.yml

@@ -38,18 +38,6 @@ jobs:
           - 5432:5432
         # needed because the postgres container does not provide a healthcheck
         options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
-      postgres-tls:
-        image: nimbustech/postgres-ssl:9.5
-        env:
-          POSTGRES_USER: postgres
-          POSTGRES_PASSWORD: postgres
-          POSTGRES_DB: postgres
-        ports:
-          - 5433:5432
-        volumes:
-          - tests/cert:/var/ssl
-        # needed because the postgres container does not provide a healthcheck
-        options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
     steps:
       - name: Install psql
         run: |
@@ -72,4 +60,3 @@ jobs:
           args: --all --all-features --no-fail-fast -- --nocapture
         env:
           TEST_URL: "postgresql://localhost/postgres?user=postgres&password=postgres"
-          TEST_TLS_URL: "postgresql://localhost:5433/postgres?user=postgres&password=postgres?sslmode=verify-ca"

Cargo.toml

@@ -10,6 +10,10 @@ readme = "../README.md"
 keywords = ["database", "postgres", "postgresql", "sql", "async"]
 categories = ["database"]
 
+[badges]
+codecov = { repository = "Hexilee/async-postgres" }
+
+
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
@@ -18,8 +22,7 @@ tokio-postgres = { version = "0.5.2", default-features = false }
 tokio = "0.2.14"
 async-std = "1.5"
 futures = { version = "0.3.4", default-features = false }
-tokio-rustls = { version = "0.13.0", features = ["unstable"] }
-webpki = "0.21.2"
+
 
 [dev-dependencies]
 async-std = { version = "1.5", features = ["attributes"] }

src/lib.rs

@@ -2,15 +2,40 @@
 
 #![warn(missing_docs)]
 
-#[doc(no_inline)]
+pub use stream::AsyncStream;
 pub use tokio_postgres::*;
 
-#[doc(inline)]
-pub use tls::{connect_with, Connection, TlsConfig};
-
 use std::io;
+use stream::connect_stream;
+use tokio_postgres::tls::{NoTls, NoTlsStream, TlsConnect};
+use tokio_postgres::{Client, Connection};
+
+/// Connect to postgres server.
+///
+/// ```rust
+/// use async_postgres::connect;
+///
+/// use std::error::Error;
+/// use async_std::task::spawn;
+///
+/// async fn play() -> Result<(), Box<dyn Error>> {
+///     let url = "host=localhost user=postgres";
+///     let (client, conn) = connect(url.parse()?).await?;
+///     spawn(conn);
+///     let row = client.query_one("SELECT * FROM user WHERE id=$1", &[&0]).await?;
+///     let value: &str = row.get(0);
+///     println!("value: {}", value);
+///     Ok(())
+/// }
+/// ```
+#[inline]
+pub async fn connect(
+    config: Config,
+) -> io::Result<(Client, Connection<AsyncStream, NoTlsStream>)> {
+    connect_tls(config, NoTls).await
+}
 
-/// Connect to postgres server with default tls config.
+/// Connect to postgres server with a tls connector.
 ///
 /// ```rust
 /// use async_postgres::connect;
@@ -20,7 +45,7 @@ use std::io;
 ///
 /// async fn play() -> Result<(), Box<dyn Error>> {
 ///     let url = "host=localhost user=postgres";
-///     let (client, conn) = connect(&url.parse()?).await?;
+///     let (client, conn) = connect(url.parse()?).await?;
 ///     spawn(conn);
 ///     let row = client.query_one("SELECT * FROM user WHERE id=$1", &[&0]).await?;
 ///     let value: &str = row.get(0);
@@ -29,9 +54,18 @@ use std::io;
 /// }
 /// ```
 #[inline]
-pub async fn connect(config: &Config) -> io::Result<(Client, Connection)> {
-    connect_with(config, TlsConfig::default()).await
+pub async fn connect_tls<T>(
+    config: Config,
+    tls: T,
+) -> io::Result<(Client, Connection<AsyncStream, T::Stream>)>
+where
+    T: TlsConnect<AsyncStream>,
+{
+    let stream = connect_stream(&config).await?;
+    config
+        .connect_raw(stream, tls)
+        .await
+        .map_err(|err| io::Error::new(io::ErrorKind::Other, err))
 }
 
 mod stream;
-mod tls;

src/stream.rs

@@ -1,16 +1,18 @@
 use async_std::io::{self, Read, Write};
+use async_std::net::TcpStream;
 use std::mem::MaybeUninit;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 use tokio::io::{AsyncRead, AsyncWrite};
+use tokio_postgres::config::{Config, Host};
 
-/// A adaptor between futures::io::{AsyncRead, AsyncWrite} and tokio::io::{AsyncRead, AsyncWrite}.
-pub struct AsyncStream<IO>(pub IO);
+/// Default port of postgres.
+const DEFAULT_PORT: u16 = 5432;
 
-impl<IO> AsyncRead for AsyncStream<IO>
-where
-    IO: Unpin + Read,
-{
+/// A wrapper for async_std::net::TcpStream, implementing tokio::io::{AsyncRead, AsyncWrite}.
+pub struct AsyncStream(TcpStream);
+
+impl AsyncRead for AsyncStream {
     #[inline]
     unsafe fn prepare_uninitialized_buffer(&self, _buf: &mut [MaybeUninit<u8>]) -> bool {
         false
@@ -26,10 +28,7 @@ where
     }
 }
 
-impl<IO> AsyncWrite for AsyncStream<IO>
-where
-    IO: Unpin + Write,
-{
+impl AsyncWrite for AsyncStream {
     #[inline]
     fn poll_write(
         mut self: Pin<&mut Self>,
@@ -55,3 +54,41 @@ where
         Pin::new(&mut self.0).poll_close(cx)
     }
 }
+
+/// Establish connection to postgres server by AsyncStream.
+#[inline]
+pub async fn connect_stream(config: &Config) -> io::Result<AsyncStream> {
+    let host = try_tcp_host(&config)?;
+    let port = config
+        .get_ports()
+        .iter()
+        .copied()
+        .next()
+        .unwrap_or(DEFAULT_PORT);
+
+    let tcp_stream = TcpStream::connect((host, port)).await?;
+    Ok(AsyncStream(tcp_stream))
+}
+
+/// Try to get TCP hostname from postgres config.
+#[inline]
+fn try_tcp_host(config: &Config) -> io::Result<&str> {
+    match config
+        .get_hosts()
+        .iter()
+        .filter_map(|host| {
+            if let Host::Tcp(value) = host {
+                Some(value)
+            } else {
+                None
+            }
+        })
+        .next()
+    {
+        Some(host) => Ok(host),
+        None => Err(io::Error::new(
+            io::ErrorKind::Other,
+            "At least one tcp hostname is required",
+        )),
+    }
+}