Overhaul connection APIs

* `Connection` is now parameterized over the stream type, which can be
    any `AsyncRead + AsyncWrite`.
* The `TlsMode` enum is now a trait, and `NoTls`, `PreferTls`, and
    `RequireTls` are types implementing that trait.
* The `TlsConnect` trait no longer involves trait objects, and returns
    channel binding info alongside the stream type rather than requiring
    the stream to implement an additional trait.
* The `connect` free function and `ConnectParams` type is gone in favor
    of a `Builder` type. It takes a pre-connected stream rather than
    automatically opening a TCP or Unix socket connection.

Notably, we no longer have any dependency on the Tokio runtime. We do
use the `tokio-codec` and `tokio-io` crates, but those don't actually
depend on mio/tokio-reactor/etc. This means we can work with other
futures-based networking stacks.

We will almost certainly add back a convenience API that offers
something akin to the old logic to open a TCP/Unix connection
automatically but that will be worked out in a follow up PR.

Author: sfackler

.circleci/config.yml

@@ -22,7 +22,7 @@ version: 2
 jobs:
   build:
     docker:
-      - image: rust:1.26.2
+      - image: rust:1.30.1
         environment:
           RUSTFLAGS: -D warnings
       - image: sfackler/rust-postgres-test:4

docker/Dockerfile

@@ -1,3 +1,3 @@
-FROM postgres:11-beta1
+FROM postgres:11
 
 COPY sql_setup.sh /docker-entrypoint-initdb.d/

tokio-postgres-native-tls/Cargo.toml

@@ -4,7 +4,6 @@ version = "0.1.0"
 authors = ["Steven Fackler <[email protected]>"]
 
 [dependencies]
-bytes = "0.4"
 futures = "0.1"
 native-tls = "0.2"
 tokio-io = "0.1"

tokio-postgres-native-tls/src/lib.rs

@@ -1,106 +1,71 @@
-extern crate bytes;
-extern crate futures;
 extern crate native_tls;
 extern crate tokio_io;
 extern crate tokio_postgres;
 extern crate tokio_tls;
 
+#[macro_use]
+extern crate futures;
+
 #[cfg(test)]
 extern crate tokio;
 
-use bytes::{Buf, BufMut};
-use futures::{Future, Poll};
-use std::error::Error;
-use std::io::{self, Read, Write};
+use futures::{Async, Future, Poll};
 use tokio_io::{AsyncRead, AsyncWrite};
-use tokio_postgres::tls::{Socket, TlsConnect, TlsStream};
+use tokio_postgres::{ChannelBinding, TlsConnect};
+use tokio_tls::{Connect, TlsStream};
 
 #[cfg(test)]
 mod test;
 
 pub struct TlsConnector {
     connector: tokio_tls::TlsConnector,
+    domain: String,
 }
 
 impl TlsConnector {
-    pub fn new() -> Result<TlsConnector, native_tls::Error> {
+    pub fn new(domain: &str) -> Result<TlsConnector, native_tls::Error> {
         let connector = native_tls::TlsConnector::new()?;
-        Ok(TlsConnector::with_connector(connector))
+        Ok(TlsConnector::with_connector(connector, domain))
     }
 
-    pub fn with_connector(connector: native_tls::TlsConnector) -> TlsConnector {
+    pub fn with_connector(connector: native_tls::TlsConnector, domain: &str) -> TlsConnector {
         TlsConnector {
             connector: tokio_tls::TlsConnector::from(connector),
+            domain: domain.to_string(),
         }
     }
 }
 
-impl TlsConnect for TlsConnector {
-    fn connect(
-        &self,
-        domain: &str,
-        socket: Socket,
-    ) -> Box<Future<Item = Box<TlsStream>, Error = Box<Error + Sync + Send>> + Sync + Send> {
-        let f = self
-            .connector
-            .connect(domain, socket)
-            .map(|s| {
-                let s: Box<TlsStream> = Box::new(SslStream(s));
-                s
-            }).map_err(|e| {
-                let e: Box<Error + Sync + Send> = Box::new(e);
-                e
-            });
-        Box::new(f)
-    }
-}
-
-struct SslStream(tokio_tls::TlsStream<Socket>);
-
-impl Read for SslStream {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        self.0.read(buf)
-    }
-}
-
-impl AsyncRead for SslStream {
-    unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [u8]) -> bool {
-        self.0.prepare_uninitialized_buffer(buf)
-    }
+impl<S> TlsConnect<S> for TlsConnector
+where
+    S: AsyncRead + AsyncWrite,
+{
+    type Stream = TlsStream<S>;
+    type Error = native_tls::Error;
+    type Future = TlsConnectFuture<S>;
 
-    fn read_buf<B>(&mut self, buf: &mut B) -> Poll<usize, io::Error>
-    where
-        B: BufMut,
-    {
-        self.0.read_buf(buf)
+    fn connect(self, stream: S) -> TlsConnectFuture<S> {
+        TlsConnectFuture(self.connector.connect(&self.domain, stream))
     }
 }
 
-impl Write for SslStream {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.0.write(buf)
-    }
+pub struct TlsConnectFuture<S>(Connect<S>);
 
-    fn flush(&mut self) -> io::Result<()> {
-        self.0.flush()
-    }
-}
+impl<S> Future for TlsConnectFuture<S>
+where
+    S: AsyncRead + AsyncWrite,
+{
+    type Item = (TlsStream<S>, ChannelBinding);
+    type Error = native_tls::Error;
 
-impl AsyncWrite for SslStream {
-    fn shutdown(&mut self) -> Poll<(), io::Error> {
-        self.0.shutdown()
-    }
+    fn poll(&mut self) -> Poll<(TlsStream<S>, ChannelBinding), native_tls::Error> {
+        let stream = try_ready!(self.0.poll());
+        let mut channel_binding = ChannelBinding::new();
 
-    fn write_buf<B>(&mut self, buf: &mut B) -> Poll<usize, io::Error>
-    where
-        B: Buf,
-    {
-        self.0.write_buf(buf)
-    }
-}
+        if let Some(buf) = stream.get_ref().tls_server_end_point().unwrap_or(None) {
+            channel_binding = channel_binding.tls_server_end_point(buf);
+        }
 
-impl TlsStream for SslStream {
-    fn tls_server_end_point(&self) -> Option<Vec<u8>> {
-        self.0.get_ref().tls_server_end_point().unwrap_or(None)
+        Ok(Async::Ready((stream, channel_binding)))
     }
 }

tokio-postgres-native-tls/src/test.rs

@@ -1,17 +1,24 @@
 use futures::{Future, Stream};
 use native_tls::{self, Certificate};
+use tokio::net::TcpStream;
 use tokio::runtime::current_thread::Runtime;
-use tokio_postgres::{self, TlsMode};
+use tokio_postgres::{self, PreferTls, RequireTls, TlsMode};
 
 use TlsConnector;
 
-fn smoke_test(url: &str, tls: TlsMode) {
+fn smoke_test<T>(builder: &tokio_postgres::Builder, tls: T)
+where
+    T: TlsMode<TcpStream>,
+    T::Stream: 'static,
+{
     let mut runtime = Runtime::new().unwrap();
 
-    let handshake = tokio_postgres::connect(url.parse().unwrap(), tls);
+    let handshake = TcpStream::connect(&"127.0.0.1:5433".parse().unwrap())
+        .map_err(|e| panic!("{}", e))
+        .and_then(|s| builder.connect(s, tls));
     let (mut client, connection) = runtime.block_on(handshake).unwrap();
     let connection = connection.map_err(|e| panic!("{}", e));
-    runtime.handle().spawn(connection).unwrap();
+    runtime.spawn(connection);
 
     let prepare = client.prepare("SELECT 1::INT4");
     let statement = runtime.block_on(prepare).unwrap();
@@ -33,10 +40,11 @@ fn require() {
             Certificate::from_pem(include_bytes!("../../test/server.crt")).unwrap(),
         ).build()
         .unwrap();
-    let connector = TlsConnector::with_connector(connector);
     smoke_test(
-        "postgres://ssl_user@localhost:5433/postgres",
-        TlsMode::Require(Box::new(connector)),
+        tokio_postgres::Builder::new()
+            .user("ssl_user")
+            .database("postgres"),
+        RequireTls(TlsConnector::with_connector(connector, "localhost")),
     );
 }
 
@@ -47,10 +55,11 @@ fn prefer() {
             Certificate::from_pem(include_bytes!("../../test/server.crt")).unwrap(),
         ).build()
         .unwrap();
-    let connector = TlsConnector::with_connector(connector);
     smoke_test(
-        "postgres://ssl_user@localhost:5433/postgres",
-        TlsMode::Prefer(Box::new(connector)),
+        tokio_postgres::Builder::new()
+            .user("ssl_user")
+            .database("postgres"),
+        PreferTls(TlsConnector::with_connector(connector, "localhost")),
     );
 }
 
@@ -61,9 +70,11 @@ fn scram_user() {
             Certificate::from_pem(include_bytes!("../../test/server.crt")).unwrap(),
         ).build()
         .unwrap();
-    let connector = TlsConnector::with_connector(connector);
     smoke_test(
-        "postgres://scram_user:password@localhost:5433/postgres",
-        TlsMode::Require(Box::new(connector)),
+        tokio_postgres::Builder::new()
+            .user("scram_user")
+            .password("password")
+            .database("postgres"),
+        RequireTls(TlsConnector::with_connector(connector, "localhost")),
     );
 }

tokio-postgres-openssl/Cargo.toml

@@ -4,11 +4,10 @@ version = "0.1.0"
 authors = ["Steven Fackler <[email protected]>"]
 
 [dependencies]
-bytes = "0.4"
 futures = "0.1"
 openssl = "0.10"
 tokio-io = "0.1"
-tokio-openssl = "0.2"
+tokio-openssl = "0.3"
 tokio-postgres = { version = "0.3", path = "../tokio-postgres" }
 
 [dev-dependencies]