Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-07-22 23:03:42 +01:00
Code Issues Projects Releases Packages Wiki Activity

Upgrade Hyper

Browse source
This commit is contained in:
Naveen Gattu 2021-12-23 11:15:35 -08:00
parent 5df705a41f
commit a48a111cee
42 changed files with 872 additions and 891 deletions
Download patch file Download diff file Expand all files Collapse all files

2
components/net/tests/fetch.rs
View file

@ -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;

2
components/net/tests/http_cache.rs
View file

@ -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() {

28
components/net/tests/http_loader.rs
View file

@ -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(),

171
components/net/tests/main.rs
View file

@ -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 server = async move {
loop {
let stream = tokio::select! {
stream = listener.next() => stream,
_ = &mut rx => break
};
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 stream = match stream {
Some(stream) => stream.expect("Could not accept stream: "),
_ => break,
};
let (tx, rx) = futures::sync::oneshot::channel::<()>();
let server = server
.select(rx.map_err(|_| ()))
.map(|_| ())
.map_err(|_| ());
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 _ = 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);

2
components/net/tests/mime_classifier.rs
View file

@ -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,
]);