Upgrade Hyper

author: Naveen Gattu <naveen.gattu@gmail.com> 2021-12-23 11:15:35 -0800
committer: Naveen Gattu <naveen.gattu@gmail.com> 2022-01-16 09:34:17 -0800
commit: a48a111cee6298f4628d4ae12b60a43c1b17cecf (patch)
tree: af1ff0300471853886267631e2d66c937a604e9e /components/net/tests
parent: 5df705a41f6c4c1f2ffeec257dfe0129ce5fa8e0 (diff)
download: servo-a48a111cee6298f4628d4ae12b60a43c1b17cecf.tar.gz
servo-a48a111cee6298f4628d4ae12b60a43c1b17cecf.zip
5 files changed, 114 insertions, 93 deletions
diff --git a/components/net/tests/fetch.rs b/components/net/tests/fetch.rs
index 9416a81e8de..4c0149b8f1a 100644
--- a/components/net/tests/fetch.rs
+++ b/components/net/tests/fetch.rs
@@ -20,7 +20,7 @@ use headers::{AccessControlAllowMethods, AccessControlMaxAge, HeaderMapExt};
 use headers::{CacheControl, ContentLength, ContentType, Expires, LastModified, Pragma, UserAgent};
 use http::header::{self, HeaderMap, HeaderName, HeaderValue};
 use http::{Method, StatusCode};
-use hyper::body::Body;
+use hyper::Body;
 use hyper::{Request as HyperRequest, Response as HyperResponse};
 use mime::{self, Mime};
 use msg::constellation_msg::TEST_PIPELINE_ID;
diff --git a/components/net/tests/http_cache.rs b/components/net/tests/http_cache.rs
index 8dd09b650da..30a4052928a 100644
--- a/components/net/tests/http_cache.rs
+++ b/components/net/tests/http_cache.rs
@@ -10,7 +10,7 @@ use net_traits::request::{Origin, Referrer, Request};
 use net_traits::response::{HttpsState, Response, ResponseBody};
 use net_traits::{ResourceFetchTiming, ResourceTimingType};
 use servo_url::ServoUrl;
-use tokio2::sync::mpsc::unbounded_channel as unbounded;
+use tokio::sync::mpsc::unbounded_channel as unbounded;
 
 #[test]
 fn test_refreshing_resource_sets_done_chan_the_appropriate_value() {
diff --git a/components/net/tests/http_loader.rs b/components/net/tests/http_loader.rs
index e9de2cb983f..e84b0ec3fc5 100644
--- a/components/net/tests/http_loader.rs
+++ b/components/net/tests/http_loader.rs
@@ -15,7 +15,6 @@ use devtools_traits::HttpResponse as DevtoolsHttpResponse;
 use devtools_traits::{ChromeToDevtoolsControlMsg, DevtoolsControlMsg, NetworkEvent};
 use flate2::write::{DeflateEncoder, GzEncoder};
 use flate2::Compression;
-use futures::{self, Future, Stream};
 use headers::authorization::Basic;
 use headers::{
     Authorization, ContentLength, Date, HeaderMapExt, Host, StrictTransportSecurity, UserAgent,
@@ -23,7 +22,7 @@ use headers::{
 use http::header::{self, HeaderMap, HeaderValue};
 use http::uri::Authority;
 use http::{Method, StatusCode};
-use hyper::body::Body;
+use hyper::Body;
 use hyper::{Request as HyperRequest, Response as HyperResponse};
 use ipc_channel::ipc;
 use ipc_channel::router::ROUTER;
@@ -51,13 +50,6 @@ fn mock_origin() -> ImmutableOrigin {
     ServoUrl::parse("http://servo.org").unwrap().origin()
 }
 
-fn read_response(req: HyperRequest<Body>) -> impl Future<Item = String, Error = ()> {
-    req.into_body()
-        .concat2()
-        .and_then(|body| futures::future::ok(str::from_utf8(&body).unwrap().to_owned()))
-        .map_err(|_| ())
-}
-
 fn assert_cookie_for_domain(
     cookie_jar: &RwLock<CookieStorage>,
     domain: &str,
@@ -521,28 +513,18 @@ fn test_load_should_decode_the_response_as_gzip_when_response_headers_have_conte
 
 #[test]
 fn test_load_doesnt_send_request_body_on_any_redirect() {
+    use hyper::body::HttpBody;
+
     let post_handler = move |request: HyperRequest<Body>, response: &mut HyperResponse<Body>| {
         assert_eq!(request.method(), Method::GET);
-        read_response(request)
-            .and_then(|data| {
-                assert_eq!(data, "");
-                futures::future::ok(())
-            })
-            .poll()
-            .unwrap();
+        assert_eq!(request.size_hint().exact(), Some(0));
         *response.body_mut() = b"Yay!".to_vec().into();
     };
     let (post_server, post_url) = make_server(post_handler);
 
     let post_redirect_url = post_url.clone();
     let pre_handler = move |request: HyperRequest<Body>, response: &mut HyperResponse<Body>| {
-        read_response(request)
-            .and_then(|data| {
-                assert_eq!(data, "Body on POST");
-                futures::future::ok(())
-            })
-            .poll()
-            .unwrap();
+        assert_eq!(request.size_hint().exact(), Some(13));
         response.headers_mut().insert(
             header::LOCATION,
             HeaderValue::from_str(&post_redirect_url.to_string()).unwrap(),
diff --git a/components/net/tests/main.rs b/components/net/tests/main.rs
index f814980f4aa..46f3eb1bb05 100644
--- a/components/net/tests/main.rs
+++ b/components/net/tests/main.rs
@@ -21,14 +21,17 @@ mod mime_classifier;
 mod resource_thread;
 mod subresource_integrity;
 
+use core::convert::Infallible;
+use core::pin::Pin;
 use crossbeam_channel::{unbounded, Sender};
 use devtools_traits::DevtoolsControlMsg;
 use embedder_traits::resources::{self, Resource};
 use embedder_traits::{EmbedderProxy, EventLoopWaker};
-use futures::{Future, Stream};
+use futures::future::ready;
+use futures::StreamExt;
 use hyper::server::conn::Http;
 use hyper::server::Server as HyperServer;
-use hyper::service::service_fn_ok;
+use hyper::service::{make_service_fn, service_fn};
 use hyper::{Body, Request as HyperRequest, Response as HyperResponse};
 use net::connector::{create_tls_config, ConnectionCerts, ExtraCerts, ALPN_H2_H1};
 use net::fetch::cors_cache::CorsCache;
@@ -40,20 +43,27 @@ use net_traits::filemanager_thread::FileTokenCheck;
 use net_traits::request::Request;
 use net_traits::response::Response;
 use net_traits::{FetchTaskTarget, ResourceFetchTiming, ResourceTimingType};
-use openssl::ssl::{SslAcceptor, SslFiletype, SslMethod};
+use openssl::ssl::{Ssl, SslAcceptor, SslFiletype, SslMethod};
 use servo_arc::Arc as ServoArc;
 use servo_url::ServoUrl;
 use std::net::TcpListener as StdTcpListener;
 use std::path::PathBuf;
 use std::sync::{Arc, Mutex, Weak};
 use tokio::net::TcpListener;
-use tokio::reactor::Handle;
-use tokio::runtime::Runtime;
-use tokio_openssl::SslAcceptorExt;
+use tokio::net::TcpStream;
+use tokio::runtime::{Builder, Runtime};
+use tokio_openssl::SslStream;
+use tokio_stream::wrappers::TcpListenerStream;
 use tokio_test::block_on;
 
 lazy_static! {
-    pub static ref HANDLE: Mutex<Runtime> = Mutex::new(Runtime::new().unwrap());
+    pub static ref HANDLE: Mutex<Runtime> = Mutex::new(
+        Builder::new_multi_thread()
+            .enable_io()
+            .worker_threads(10)
+            .build()
+            .unwrap()
+    );
 }
 
 const DEFAULT_USER_AGENT: &'static str = "Such Browser. Very Layout. Wow.";
@@ -134,33 +144,34 @@ fn fetch(request: &mut Request, dc: Option<Sender<DevtoolsControlMsg>>) -> Respo
 fn fetch_with_context(request: &mut Request, mut context: &mut FetchContext) -> Response {
     let (sender, receiver) = unbounded();
     let mut target = FetchResponseCollector { sender: sender };
-
-    block_on(methods::fetch(request, &mut target, &mut context));
-
-    receiver.recv().unwrap()
+    block_on(async move {
+        methods::fetch(request, &mut target, &mut context).await;
+        receiver.recv().unwrap()
+    })
 }
 
 fn fetch_with_cors_cache(request: &mut Request, cache: &mut CorsCache) -> Response {
     let (sender, receiver) = unbounded();
     let mut target = FetchResponseCollector { sender: sender };
-
-    block_on(methods::fetch_with_cors_cache(
-        request,
-        cache,
-        &mut target,
-        &mut new_fetch_context(None, None, None),
-    ));
-
-    receiver.recv().unwrap()
+    block_on(async move {
+        methods::fetch_with_cors_cache(
+            request,
+            cache,
+            &mut target,
+            &mut new_fetch_context(None, None, None),
+        )
+        .await;
+        receiver.recv().unwrap()
+    })
 }
 
 pub(crate) struct Server {
-    pub close_channel: futures::sync::oneshot::Sender<()>,
+    pub close_channel: tokio::sync::oneshot::Sender<()>,
 }
 
 impl Server {
     fn close(self) {
-        self.close_channel.send(()).unwrap();
+        self.close_channel.send(()).expect("err closing server:");
     }
 }
 
@@ -172,19 +183,26 @@ where
     let listener = StdTcpListener::bind("0.0.0.0:0").unwrap();
     let url_string = format!("http://localhost:{}", listener.local_addr().unwrap().port());
     let url = ServoUrl::parse(&url_string).unwrap();
-    let (tx, rx) = futures::sync::oneshot::channel::<()>();
-    let server = HyperServer::from_tcp(listener)
-        .unwrap()
-        .serve(move || {
-            let handler = handler.clone();
-            service_fn_ok(move |req: HyperRequest<Body>| {
-                let mut response = HyperResponse::new(Vec::<u8>::new().into());
-                handler(req, &mut response);
-                response
+    let (tx, rx) = tokio::sync::oneshot::channel::<()>();
+    let server = async move {
+        HyperServer::from_tcp(listener)
+            .unwrap()
+            .serve(make_service_fn(move |_| {
+                let handler = handler.clone();
+                ready(Ok::<_, Infallible>(service_fn(
+                    move |req: HyperRequest<Body>| {
+                        let mut response = HyperResponse::new(Vec::<u8>::new().into());
+                        handler(req, &mut response);
+                        ready(Ok::<_, Infallible>(response))
+                    },
+                )))
+            }))
+            .with_graceful_shutdown(async move {
+                rx.await.ok();
             })
-        })
-        .with_graceful_shutdown(rx)
-        .map_err(|_| ());
+            .await
+            .expect("Could not start server");
+    };
 
     HANDLE.lock().unwrap().spawn(server);
     let server = Server { close_channel: tx };
@@ -197,43 +215,64 @@ where
 {
     let handler = Arc::new(handler);
     let listener = StdTcpListener::bind("[::0]:0").unwrap();
-    let listener = TcpListener::from_std(listener, &Handle::default()).unwrap();
+    let listener = HANDLE
+        .lock()
+        .unwrap()
+        .block_on(async move { TcpListener::from_std(listener).unwrap() });
+
     let url_string = format!("http://localhost:{}", listener.local_addr().unwrap().port());
+    let mut listener = TcpListenerStream::new(listener);
+
     let url = ServoUrl::parse(&url_string).unwrap();
+    let (tx, mut rx) = tokio::sync::oneshot::channel::<()>();
 
-    let server = listener.incoming().map_err(|_| ()).for_each(move |sock| {
-        let mut tls_server_config = SslAcceptor::mozilla_intermediate_v5(SslMethod::tls()).unwrap();
-        tls_server_config
-            .set_certificate_file(&cert_path, SslFiletype::PEM)
-            .unwrap();
-        tls_server_config
-            .set_private_key_file(&key_path, SslFiletype::PEM)
-            .unwrap();
-
-        let handler = handler.clone();
-        tls_server_config
-            .build()
-            .accept_async(sock)
-            .map_err(|_| ())
-            .and_then(move |ssl| {
-                Http::new()
-                    .serve_connection(
-                        ssl,
-                        service_fn_ok(move |req: HyperRequest<Body>| {
-                            let mut response = HyperResponse::new(Vec::<u8>::new().into());
-                            handler(req, &mut response);
-                            response
-                        }),
-                    )
-                    .map_err(|_| ())
-            })
-    });
+    let server = async move {
+        loop {
+            let stream = tokio::select! {
+                stream = listener.next() => stream,
+                _ = &mut rx => break
+            };
+
+            let stream = match stream {
+                Some(stream) => stream.expect("Could not accept stream: "),
+                _ => break,
+            };
+
+            let stream = stream.into_std().unwrap();
+            stream
+                .set_read_timeout(Some(std::time::Duration::new(5, 0)))
+                .unwrap();
+            let stream = TcpStream::from_std(stream).unwrap();
+
+            let mut tls_server_config =
+                SslAcceptor::mozilla_intermediate_v5(SslMethod::tls()).unwrap();
+            tls_server_config
+                .set_certificate_file(&cert_path, SslFiletype::PEM)
+                .unwrap();
+            tls_server_config
+                .set_private_key_file(&key_path, SslFiletype::PEM)
+                .unwrap();
+
+            let tls_server_config = tls_server_config.build();
+            let ssl = Ssl::new(tls_server_config.context()).unwrap();
+            let mut stream = SslStream::new(ssl, stream).unwrap();
 
-    let (tx, rx) = futures::sync::oneshot::channel::<()>();
-    let server = server
-        .select(rx.map_err(|_| ()))
-        .map(|_| ())
-        .map_err(|_| ());
+            let _ = Pin::new(&mut stream).accept().await;
+
+            let handler = handler.clone();
+
+            let _ = Http::new()
+                .serve_connection(
+                    stream,
+                    service_fn(move |req: HyperRequest<Body>| {
+                        let mut response = HyperResponse::new(Body::empty());
+                        handler(req, &mut response);
+                        ready(Ok::<_, Infallible>(response))
+                    }),
+                )
+                .await;
+        }
+    };
 
     HANDLE.lock().unwrap().spawn(server);
 
diff --git a/components/net/tests/mime_classifier.rs b/components/net/tests/mime_classifier.rs
index 3317b355d71..0fac4a027e2 100644
--- a/components/net/tests/mime_classifier.rs
+++ b/components/net/tests/mime_classifier.rs
@@ -43,7 +43,7 @@ fn test_sniff_mp4_matcher_long() {
     let matcher = Mp4Matcher;
 
     let mut data: [u8; 260] = [0; 260];
-    &data[..11].clone_from_slice(&[
+    let _ = &data[..11].clone_from_slice(&[
         0x00, 0x00, 0x01, 0x04, 0x66, 0x74, 0x79, 0x70, 0x6D, 0x70, 0x34,
     ]);
author	Naveen Gattu <naveen.gattu@gmail.com>	2021-12-23 11:15:35 -0800
committer	Naveen Gattu <naveen.gattu@gmail.com>	2022-01-16 09:34:17 -0800
commit	a48a111cee6298f4628d4ae12b60a43c1b17cecf (patch)
tree	af1ff0300471853886267631e2d66c937a604e9e /components/net/tests
parent	5df705a41f6c4c1f2ffeec257dfe0129ce5fa8e0 (diff)
download	servo-a48a111cee6298f4628d4ae12b60a43c1b17cecf.tar.gz servo-a48a111cee6298f4628d4ae12b60a43c1b17cecf.zip