bump actix-server to beta 9 (#2442)

actix-http-test/src/lib.rs

@@ -7,7 +7,7 @@
 #[cfg(feature = "openssl")]
 extern crate tls_openssl as openssl;
 
-use std::{net, sync::mpsc, thread, time::Duration};
+use std::{net, thread, time::Duration};
 
 use actix_codec::{AsyncRead, AsyncWrite, Framed};
 use actix_rt::{net::TcpStream, System};
@@ -19,6 +19,7 @@ use bytes::Bytes;
 use futures_core::stream::Stream;
 use http::Method;
 use socket2::{Domain, Protocol, Socket, Type};
+use tokio::sync::mpsc;
 
 /// Start test server
 ///
@@ -55,12 +56,13 @@ pub async fn test_server<F: ServiceFactory<TcpStream>>(factory: F) -> TestServer
     test_server_with_addr(tcp, factory).await
 }
 
-/// Start [`test server`](test_server()) on a concrete Address
+/// Start [`test server`](test_server()) on an existing address binding.
 pub async fn test_server_with_addr<F: ServiceFactory<TcpStream>>(
     tcp: net::TcpListener,
     factory: F,
 ) -> TestServer {
-    let (tx, rx) = mpsc::channel();
+    let (started_tx, started_rx) = std::sync::mpsc::channel();
+    let (thread_stop_tx, thread_stop_rx) = mpsc::channel(1);
 
     // run server in separate thread
     thread::spawn(move || {
@@ -68,59 +70,73 @@ pub async fn test_server_with_addr<F: ServiceFactory<TcpStream>>(
         let local_addr = tcp.local_addr().unwrap();
 
         let srv = Server::build()
-            .listen("test", tcp, factory)?
             .workers(1)
-            .disable_signals();
+            .disable_signals()
+            .listen("test", tcp, factory)
+            .expect("test server could not be created");
 
-        sys.block_on(async {
-            srv.run();
-            tx.send((System::current(), local_addr)).unwrap();
-        });
+        let srv = srv.run();
+        started_tx
+            .send((System::current(), srv.handle(), local_addr))
+            .unwrap();
 
-        sys.run()
+        // drive server loop
+        sys.block_on(srv).unwrap();
+
+        // start system event loop
+        sys.run().unwrap();
+
+        // notify TestServer that server and system have shut down
+        // all thread managed resources should be dropped at this point
+        let _ = thread_stop_tx.send(());
     });
 
-    let (system, addr) = rx.recv().unwrap();
+    let (system, server, addr) = started_rx.recv().unwrap();
 
     let client = {
+        #[cfg(feature = "openssl")]
         let connector = {
-            #[cfg(feature = "openssl")]
-            {
-                use openssl::ssl::{SslConnector, SslMethod, SslVerifyMode};
+            use openssl::ssl::{SslConnector, SslMethod, SslVerifyMode};
 
-                let mut builder = SslConnector::builder(SslMethod::tls()).unwrap();
-                builder.set_verify(SslVerifyMode::NONE);
-                let _ = builder
-                    .set_alpn_protos(b"\x02h2\x08http/1.1")
-                    .map_err(|e| log::error!("Can not set alpn protocol: {:?}", e));
-                Connector::new()
-                    .conn_lifetime(Duration::from_secs(0))
-                    .timeout(Duration::from_millis(30000))
-                    .ssl(builder.build())
-            }
-            #[cfg(not(feature = "openssl"))]
-            {
-                Connector::new()
-                    .conn_lifetime(Duration::from_secs(0))
-                    .timeout(Duration::from_millis(30000))
-            }
+            let mut builder = SslConnector::builder(SslMethod::tls()).unwrap();
+
+            builder.set_verify(SslVerifyMode::NONE);
+            let _ = builder
+                .set_alpn_protos(b"\x02h2\x08http/1.1")
+                .map_err(|e| log::error!("Can not set alpn protocol: {:?}", e));
+
+            Connector::new()
+                .conn_lifetime(Duration::from_secs(0))
+                .timeout(Duration::from_millis(30000))
+                .ssl(builder.build())
+        };
+
+        #[cfg(not(feature = "openssl"))]
+        let connector = {
+            Connector::new()
+                .conn_lifetime(Duration::from_secs(0))
+                .timeout(Duration::from_millis(30000))
         };
 
         Client::builder().connector(connector).finish()
     };
 
     TestServer {
-        addr,
+        server,
         client,
         system,
+        addr,
+        thread_stop_rx,
     }
 }
 
 /// Test server controller
 pub struct TestServer {
+    server: actix_server::ServerHandle,
+    client: awc::Client,
+    system: actix_rt::System,
     addr: net::SocketAddr,
-    client: Client,
-    system: System,
+    thread_stop_rx: mpsc::Receiver<()>,
 }
 
 impl TestServer {
@@ -257,15 +273,32 @@ impl TestServer {
         self.client.headers()
     }
 
-    /// Stop HTTP server
-    fn stop(&mut self) {
+    /// Gracefully stop HTTP server.
+    ///
+    /// Waits for spawned `Server` and `System` to shutdown gracefully.
+    pub async fn stop(&mut self) {
+        // signal server to stop
+        self.server.stop(true).await;
+
+        // also signal system to stop
+        // though this is handled by `ServerBuilder::exit_system` too
         self.system.stop();
+
+        // wait for thread to be stopped but don't care about result
+        let _ = self.thread_stop_rx.recv().await;
     }
 }
 
 impl Drop for TestServer {
     fn drop(&mut self) {
-        self.stop()
+        // calls in this Drop impl should be enough to shut down the server, system, and thread
+        // without needing to await anything
+
+        // signal server to stop
+        let _ = self.server.stop(true);
+
+        // signal system to stop
+        self.system.stop();
     }
 }