Merge pull request #7 from http-rs/tide-v0.15

update for tide v0.15

Author: yoshuawuyts

Cargo.toml

@@ -12,8 +12,8 @@ keywords = ["tide", "https", "tls"]
 categories = ["web-programming::http-server", "web-programming"]
 
 [dependencies]
-async-std = "1.6.5"
-tide = { version = "0.14.0", default-features = false }
+async-std = "1.7.0"
+tide = { version = "0.15.0", default-features = false }
 async-tls = "0.10.0"
 rustls = "0.18.1"
 async-h1 = "2.1.2"

src/tls_listener.rs

@@ -1,5 +1,6 @@
 use crate::{TcpConnection, TlsListenerBuilder, TlsListenerConfig, TlsStreamWrapper};
 
+use tide::listener::ListenInfo;
 use tide::listener::{Listener, ToListener};
 use tide::Server;
 
@@ -19,15 +20,36 @@ use std::sync::Arc;
 use std::time::Duration;
 
 /// The primary type for this crate
-#[derive(Debug)]
-pub struct TlsListener {
+pub struct TlsListener<State> {
     connection: TcpConnection,
     config: TlsListenerConfig,
+    server: Option<Server<State>>,
 }
 
-impl TlsListener {
+impl<State> Debug for TlsListener<State> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        f.debug_struct("TlsListener")
+            .field(&"connection", &self.connection)
+            .field(&"config", &self.config)
+            .field(
+                &"server",
+                if self.server.is_some() {
+                    &"Some(Server<State>)"
+                } else {
+                    &"None"
+                },
+            )
+            .finish()
+    }
+}
+
+impl<State> TlsListener<State> {
     pub(crate) fn new(connection: TcpConnection, config: TlsListenerConfig) -> Self {
-        Self { connection, config }
+        Self {
+            connection,
+            config,
+            server: None,
+        }
     }
     /// The primary entrypoint to create a TlsListener. See
     /// [TlsListenerBuilder](crate::TlsListenerBuilder) for more
@@ -37,13 +59,13 @@ impl TlsListener {
     ///
     /// ```rust
     /// # use tide_rustls::TlsListener;
-    /// let listener = TlsListener::build()
+    /// let listener = TlsListener::<()>::build()
     ///     .addrs("localhost:4433")
     ///     .cert("./tls/localhost-4433.cert")
     ///     .key("./tls/localhost-4433.key")
     ///     .finish();
     /// ```
-    pub fn build() -> TlsListenerBuilder {
+    pub fn build() -> TlsListenerBuilder<State> {
         TlsListenerBuilder::new()
     }
 
@@ -77,6 +99,20 @@ impl TlsListener {
         }
     }
 
+    fn acceptor(&self) -> Option<&TlsAcceptor> {
+        match self.config {
+            TlsListenerConfig::Acceptor(ref a) => Some(a),
+            _ => None,
+        }
+    }
+
+    fn tcp(&self) -> Option<&TcpListener> {
+        match self.connection {
+            TcpConnection::Connected(ref t) => Some(t),
+            _ => None,
+        }
+    }
+
     async fn connect(&mut self) -> io::Result<&TcpListener> {
         if let TcpConnection::Addrs(addrs) = &self.connection {
             let tcp = TcpListener::bind(&addrs[..]).await?;
@@ -125,44 +161,59 @@ fn handle_tls<State: Clone + Send + Sync + 'static>(
     });
 }
 
-impl<State: Clone + Send + Sync + 'static> ToListener<State> for TlsListener {
+impl<State: Clone + Send + Sync + 'static> ToListener<State> for TlsListener<State> {
     type Listener = Self;
     fn to_listener(self) -> io::Result<Self::Listener> {
         Ok(self)
     }
 }
 
-impl<State: Clone + Send + Sync + 'static> ToListener<State> for TlsListenerBuilder {
-    type Listener = TlsListener;
+impl<State: Clone + Send + Sync + 'static> ToListener<State> for TlsListenerBuilder<State> {
+    type Listener = TlsListener<State>;
     fn to_listener(self) -> io::Result<Self::Listener> {
         self.finish()
     }
 }
 
 #[tide::utils::async_trait]
-impl<State: Clone + Send + Sync + 'static> Listener<State> for TlsListener {
-    async fn listen(&mut self, app: Server<State>) -> io::Result<()> {
-        let acceptor = self.configure().await?;
-        let listener = self.connect().await?;
+impl<State: Clone + Send + Sync + 'static> Listener<State> for TlsListener<State> {
+    async fn bind(&mut self, server: Server<State>) -> io::Result<()> {
+        self.configure().await?;
+        self.connect().await?;
+        self.server = Some(server);
+        Ok(())
+    }
+
+    async fn accept(&mut self) -> io::Result<()> {
+        let listener = self.tcp().unwrap();
         let mut incoming = listener.incoming();
+        let acceptor = self.acceptor().unwrap();
+        let server = self.server.as_ref().unwrap();
 
         while let Some(stream) = incoming.next().await {
             match stream {
                 Err(ref e) if is_transient_error(e) => continue,
+
                 Err(error) => {
                     let delay = Duration::from_millis(500);
                     tide::log::error!("Error: {}. Pausing for {:?}.", error, delay);
                     task::sleep(delay).await;
                     continue;
                 }
 
-                Ok(stream) => {
-                    handle_tls(app.clone(), stream, acceptor.clone());
-                }
+                Ok(stream) => handle_tls(server.clone(), stream, acceptor.clone()),
             };
         }
         Ok(())
     }
+
+    fn info(&self) -> Vec<ListenInfo> {
+        vec![ListenInfo::new(
+            self.connection.to_string(),
+            String::from("tcp"),
+            true,
+        )]
+    }
 }
 
 fn is_transient_error(e: &io::Error) -> bool {
@@ -173,7 +224,7 @@ fn is_transient_error(e: &io::Error) -> bool {
     )
 }
 
-impl Display for TlsListener {
+impl<State> Display for TlsListener<State> {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.connection)
     }

src/tls_listener_builder.rs

@@ -5,6 +5,7 @@ use rustls::ServerConfig;
 
 use super::{TcpConnection, TlsListener, TlsListenerConfig};
 
+use std::marker::PhantomData;
 use std::net::{SocketAddr, ToSocketAddrs};
 use std::path::{Path, PathBuf};
 
@@ -19,7 +20,7 @@ use std::path::{Path, PathBuf};
 ///
 /// ```rust
 /// # use tide_rustls::TlsListener;
-/// let listener = TlsListener::build()
+/// let listener = TlsListener::<()>::build()
 ///     .addrs("localhost:4433")
 ///     .cert("./tls/localhost-4433.cert")
 ///     .key("./tls/localhost-4433.key")
@@ -28,21 +29,34 @@ use std::path::{Path, PathBuf};
 ///
 /// ```rust
 /// # use tide_rustls::TlsListener;
-/// let listener = TlsListener::build()
+/// let listener = TlsListener::<()>::build()
 ///     .tcp(std::net::TcpListener::bind("localhost:4433").unwrap())
 ///     .config(rustls::ServerConfig::new(rustls::NoClientAuth::new()))
 ///     .finish();
 /// ```
-#[derive(Default)]
-pub struct TlsListenerBuilder {
+pub struct TlsListenerBuilder<State> {
     key: Option<PathBuf>,
     cert: Option<PathBuf>,
     config: Option<ServerConfig>,
     tcp: Option<TcpListener>,
     addrs: Option<Vec<SocketAddr>>,
+    _state: PhantomData<State>,
 }
 
-impl std::fmt::Debug for TlsListenerBuilder {
+impl<State> Default for TlsListenerBuilder<State> {
+    fn default() -> Self {
+        Self {
+            key: None,
+            cert: None,
+            config: None,
+            tcp: None,
+            addrs: None,
+            _state: PhantomData,
+        }
+    }
+}
+
+impl<State> std::fmt::Debug for TlsListenerBuilder<State> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("TlsListenerBuilder")
             .field("key", &self.key)
@@ -61,9 +75,9 @@ impl std::fmt::Debug for TlsListenerBuilder {
     }
 }
 
-impl TlsListenerBuilder {
+impl<State> TlsListenerBuilder<State> {
     pub(crate) fn new() -> Self {
-        TlsListenerBuilder::default()
+        Self::default()
     }
 
     /// Provide a path to a key file, in either pkcs8 or rsa
@@ -123,13 +137,14 @@ impl TlsListenerBuilder {
     /// * either of these is provided, but not both
     ///   * both [`TlsListenerBuilder::cert`] AND [`TlsListenerBuilder::key`]
     ///   * [`TlsListenerBuilder::config`]
-    pub fn finish(self) -> io::Result<TlsListener> {
+    pub fn finish(self) -> io::Result<TlsListener<State>> {
         let Self {
             key,
             cert,
             config,
             tcp,
             addrs,
+            ..
         } = self;
 
         let config = match (key, cert, config) {