use one thread for accept loop; refactor rust-tls support

tests/test_server.rs

@@ -153,6 +153,62 @@ fn test_shutdown() {
     let _ = sys.stop();
 }
 
+#[test]
+#[cfg(unix)]
+fn test_panic() {
+    let _ = test::TestServer::unused_addr();
+    let (tx, rx) = mpsc::channel();
+
+    thread::spawn(|| {
+        System::run(move || {
+            let srv = server::new(|| {
+                App::new()
+                    .resource("/panic", |r| {
+                        r.method(http::Method::GET).f(|_| -> &'static str {
+                            panic!("error");
+                        });
+                    })
+                    .resource("/", |r| {
+                        r.method(http::Method::GET).f(|_| HttpResponse::Ok())
+                    })
+            }).workers(1);
+
+            let srv = srv.bind("127.0.0.1:0").unwrap();
+            let addr = srv.addrs()[0];
+            srv.start();
+            let _ = tx.send((addr, System::current()));
+        });
+    });
+    let (addr, sys) = rx.recv().unwrap();
+    System::set_current(sys.clone());
+
+    let mut rt = Runtime::new().unwrap();
+    {
+        let req = client::ClientRequest::get(format!("http://{}/panic", addr).as_str())
+            .finish()
+            .unwrap();
+        let response = rt.block_on(req.send());
+        assert!(response.is_err());
+    }
+
+    {
+        let req = client::ClientRequest::get(format!("http://{}/", addr).as_str())
+            .finish()
+            .unwrap();
+        let response = rt.block_on(req.send());
+        assert!(response.is_err());
+    }
+    {
+        let req = client::ClientRequest::get(format!("http://{}/", addr).as_str())
+            .finish()
+            .unwrap();
+        let response = rt.block_on(req.send()).unwrap();
+        assert!(response.status().is_success());
+    }
+
+    let _ = sys.stop();
+}
+
 #[test]
 fn test_simple() {
     let mut srv = test::TestServer::new(|app| app.handler(|_| HttpResponse::Ok()));

tests/test_ws.rs

@@ -277,13 +277,12 @@ fn test_ws_server_ssl() {
 
 #[test]
 #[cfg(feature = "rust-tls")]
-fn test_ws_server_ssl() {
+fn test_ws_server_rust_tls() {
     extern crate rustls;
-    use rustls::{ServerConfig, NoClientAuth};
     use rustls::internal::pemfile::{certs, rsa_private_keys};
-    use std::io::BufReader;
-    use std::sync::Arc;
+    use rustls::{NoClientAuth, ServerConfig};
     use std::fs::File;
+    use std::io::BufReader;
 
     // load ssl keys
     let mut config = ServerConfig::new(NoClientAuth::new());
@@ -293,7 +292,7 @@ fn test_ws_server_ssl() {
     let mut keys = rsa_private_keys(key_file).unwrap();
     config.set_single_cert(cert_chain, keys.remove(0)).unwrap();
 
-    let mut srv = test::TestServer::build().ssl(Arc::new(config)).start(|app| {
+    let mut srv = test::TestServer::build().rustls(config).start(|app| {
         app.handler(|req| {
             ws::start(
                 req,