1640 lines
52 KiB
Rust
1640 lines
52 KiB
Rust
#![deny(warnings)]
|
|
extern crate hyper;
|
|
extern crate futures;
|
|
extern crate tokio_core;
|
|
extern crate tokio_io;
|
|
extern crate pretty_env_logger;
|
|
|
|
use std::io::{self, Read, Write};
|
|
use std::net::TcpListener;
|
|
use std::thread;
|
|
use std::time::Duration;
|
|
|
|
use hyper::client::{Client, Request, HttpConnector};
|
|
use hyper::{Method, StatusCode};
|
|
|
|
use futures::{Future, Stream};
|
|
use futures::sync::oneshot;
|
|
|
|
use tokio_core::reactor::{Core, Handle};
|
|
|
|
fn client(handle: &Handle) -> Client<HttpConnector> {
|
|
Client::new(handle)
|
|
}
|
|
|
|
fn s(buf: &[u8]) -> &str {
|
|
::std::str::from_utf8(buf).unwrap()
|
|
}
|
|
|
|
macro_rules! test {
|
|
(
|
|
name: $name:ident,
|
|
server:
|
|
expected: $server_expected:expr,
|
|
reply: $server_reply:expr,
|
|
client:
|
|
request:
|
|
method: $client_method:ident,
|
|
url: $client_url:expr,
|
|
headers: [ $($request_headers:expr,)* ],
|
|
body: $request_body:expr,
|
|
proxy: $request_proxy:expr,
|
|
|
|
response:
|
|
status: $client_status:ident,
|
|
headers: [ $($response_headers:expr,)* ],
|
|
body: $response_body:expr,
|
|
) => (
|
|
test! {
|
|
name: $name,
|
|
server:
|
|
expected: $server_expected,
|
|
reply: $server_reply,
|
|
client:
|
|
set_host: true,
|
|
request:
|
|
method: $client_method,
|
|
url: $client_url,
|
|
headers: [ $($request_headers,)* ],
|
|
body: $request_body,
|
|
proxy: $request_proxy,
|
|
|
|
response:
|
|
status: $client_status,
|
|
headers: [ $($response_headers,)* ],
|
|
body: $response_body,
|
|
}
|
|
);
|
|
(
|
|
name: $name:ident,
|
|
server:
|
|
expected: $server_expected:expr,
|
|
reply: $server_reply:expr,
|
|
client:
|
|
set_host: $set_host:expr,
|
|
request:
|
|
method: $client_method:ident,
|
|
url: $client_url:expr,
|
|
headers: [ $($request_headers:expr,)* ],
|
|
body: $request_body:expr,
|
|
proxy: $request_proxy:expr,
|
|
|
|
response:
|
|
status: $client_status:ident,
|
|
headers: [ $($response_headers:expr,)* ],
|
|
body: $response_body:expr,
|
|
) => (
|
|
#[test]
|
|
fn $name() {
|
|
#![allow(unused)]
|
|
use hyper::header::*;
|
|
let _ = pretty_env_logger::try_init();
|
|
let mut core = Core::new().unwrap();
|
|
|
|
let res = test! {
|
|
INNER;
|
|
name: $name,
|
|
core: &mut core,
|
|
server:
|
|
expected: $server_expected,
|
|
reply: $server_reply,
|
|
client:
|
|
set_host: $set_host,
|
|
request:
|
|
method: $client_method,
|
|
url: $client_url,
|
|
headers: [ $($request_headers,)* ],
|
|
body: $request_body,
|
|
proxy: $request_proxy,
|
|
}.unwrap();
|
|
|
|
|
|
assert_eq!(res.status(), StatusCode::$client_status);
|
|
$(
|
|
assert_eq!(res.headers().get(), Some(&$response_headers));
|
|
)*
|
|
|
|
let body = core.run(res.body().concat2()).unwrap();
|
|
|
|
let expected_res_body = Option::<&[u8]>::from($response_body)
|
|
.unwrap_or_default();
|
|
assert_eq!(body.as_ref(), expected_res_body);
|
|
}
|
|
);
|
|
(
|
|
name: $name:ident,
|
|
server:
|
|
expected: $server_expected:expr,
|
|
reply: $server_reply:expr,
|
|
client:
|
|
request:
|
|
method: $client_method:ident,
|
|
url: $client_url:expr,
|
|
headers: [ $($request_headers:expr,)* ],
|
|
body: $request_body:expr,
|
|
proxy: $request_proxy:expr,
|
|
|
|
error: $err:expr,
|
|
) => (
|
|
#[test]
|
|
fn $name() {
|
|
#![allow(unused)]
|
|
use hyper::header::*;
|
|
let _ = pretty_env_logger::try_init();
|
|
let mut core = Core::new().unwrap();
|
|
|
|
let err = test! {
|
|
INNER;
|
|
name: $name,
|
|
core: &mut core,
|
|
server:
|
|
expected: $server_expected,
|
|
reply: $server_reply,
|
|
client:
|
|
set_host: true,
|
|
request:
|
|
method: $client_method,
|
|
url: $client_url,
|
|
headers: [ $($request_headers,)* ],
|
|
body: $request_body,
|
|
proxy: $request_proxy,
|
|
}.unwrap_err();
|
|
if !$err(&err) {
|
|
panic!("unexpected error: {:?}", err)
|
|
}
|
|
}
|
|
);
|
|
|
|
(
|
|
INNER;
|
|
name: $name:ident,
|
|
core: $core:expr,
|
|
server:
|
|
expected: $server_expected:expr,
|
|
reply: $server_reply:expr,
|
|
client:
|
|
set_host: $set_host:expr,
|
|
request:
|
|
method: $client_method:ident,
|
|
url: $client_url:expr,
|
|
headers: [ $($request_headers:expr,)* ],
|
|
body: $request_body:expr,
|
|
proxy: $request_proxy:expr,
|
|
) => ({
|
|
let server = TcpListener::bind("127.0.0.1:0").unwrap();
|
|
let addr = server.local_addr().unwrap();
|
|
let mut core = $core;
|
|
|
|
let mut config = Client::configure();
|
|
if !$set_host {
|
|
config = config.set_host(false);
|
|
}
|
|
let client = config.build(&core.handle());
|
|
let mut req = Request::new(Method::$client_method, format!($client_url, addr=addr).parse().unwrap());
|
|
$(
|
|
req.headers_mut().set($request_headers);
|
|
)*
|
|
|
|
if let Some(body) = $request_body {
|
|
let body: &'static str = body;
|
|
req.set_body(body);
|
|
}
|
|
req.set_proxy($request_proxy);
|
|
|
|
let res = client.request(req);
|
|
|
|
let (tx, rx) = oneshot::channel();
|
|
|
|
let thread = thread::Builder::new()
|
|
.name(format!("tcp-server<{}>", stringify!($name)));
|
|
thread.spawn(move || {
|
|
let mut inc = server.accept().unwrap().0;
|
|
inc.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
inc.set_write_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
let expected = format!($server_expected, addr=addr);
|
|
let mut buf = [0; 4096];
|
|
let mut n = 0;
|
|
while n < buf.len() && n < expected.len() {
|
|
n += match inc.read(&mut buf[n..]) {
|
|
Ok(n) => n,
|
|
Err(e) => panic!("failed to read request, partially read = {:?}, error: {}", s(&buf[..n]), e),
|
|
};
|
|
}
|
|
assert_eq!(s(&buf[..n]), expected);
|
|
|
|
inc.write_all($server_reply.as_ref()).unwrap();
|
|
let _ = tx.send(());
|
|
}).unwrap();
|
|
|
|
let rx = rx.map_err(|_| hyper::Error::Io(io::Error::new(io::ErrorKind::Other, "thread panicked")));
|
|
|
|
let work = res.join(rx).map(|r| r.0);
|
|
|
|
core.run(work)
|
|
});
|
|
}
|
|
|
|
static REPLY_OK: &'static str = "HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n";
|
|
|
|
test! {
|
|
name: client_get,
|
|
|
|
server:
|
|
expected: "GET / HTTP/1.1\r\nHost: {addr}\r\n\r\n",
|
|
reply: REPLY_OK,
|
|
|
|
client:
|
|
request:
|
|
method: Get,
|
|
url: "http://{addr}/",
|
|
headers: [],
|
|
body: None,
|
|
proxy: false,
|
|
response:
|
|
status: Ok,
|
|
headers: [
|
|
ContentLength(0),
|
|
],
|
|
body: None,
|
|
}
|
|
|
|
test! {
|
|
name: client_get_query,
|
|
|
|
server:
|
|
expected: "GET /foo?key=val HTTP/1.1\r\nHost: {addr}\r\n\r\n",
|
|
reply: REPLY_OK,
|
|
|
|
client:
|
|
request:
|
|
method: Get,
|
|
url: "http://{addr}/foo?key=val#dont_send_me",
|
|
headers: [],
|
|
body: None,
|
|
proxy: false,
|
|
response:
|
|
status: Ok,
|
|
headers: [
|
|
ContentLength(0),
|
|
],
|
|
body: None,
|
|
}
|
|
|
|
test! {
|
|
name: client_get_implicitly_empty,
|
|
|
|
server:
|
|
expected: "GET / HTTP/1.1\r\nHost: {addr}\r\n\r\n",
|
|
reply: REPLY_OK,
|
|
|
|
client:
|
|
request:
|
|
method: Get,
|
|
url: "http://{addr}/",
|
|
headers: [],
|
|
body: Some(""),
|
|
proxy: false,
|
|
response:
|
|
status: Ok,
|
|
headers: [
|
|
ContentLength(0),
|
|
],
|
|
body: None,
|
|
}
|
|
|
|
test! {
|
|
name: client_post_sized,
|
|
|
|
server:
|
|
expected: "\
|
|
POST /length HTTP/1.1\r\n\
|
|
Host: {addr}\r\n\
|
|
Content-Length: 7\r\n\
|
|
\r\n\
|
|
foo bar\
|
|
",
|
|
reply: REPLY_OK,
|
|
|
|
client:
|
|
request:
|
|
method: Post,
|
|
url: "http://{addr}/length",
|
|
headers: [
|
|
ContentLength(7),
|
|
],
|
|
body: Some("foo bar"),
|
|
proxy: false,
|
|
response:
|
|
status: Ok,
|
|
headers: [],
|
|
body: None,
|
|
}
|
|
|
|
test! {
|
|
name: client_post_chunked,
|
|
|
|
server:
|
|
expected: "\
|
|
POST /chunks HTTP/1.1\r\n\
|
|
Host: {addr}\r\n\
|
|
Transfer-Encoding: chunked\r\n\
|
|
\r\n\
|
|
B\r\n\
|
|
foo bar baz\r\n\
|
|
0\r\n\r\n\
|
|
",
|
|
reply: REPLY_OK,
|
|
|
|
client:
|
|
request:
|
|
method: Post,
|
|
url: "http://{addr}/chunks",
|
|
headers: [
|
|
TransferEncoding::chunked(),
|
|
],
|
|
body: Some("foo bar baz"),
|
|
proxy: false,
|
|
response:
|
|
status: Ok,
|
|
headers: [],
|
|
body: None,
|
|
}
|
|
|
|
test! {
|
|
name: client_post_empty,
|
|
|
|
server:
|
|
expected: "\
|
|
POST /empty HTTP/1.1\r\n\
|
|
Host: {addr}\r\n\
|
|
Content-Length: 0\r\n\
|
|
\r\n\
|
|
",
|
|
reply: REPLY_OK,
|
|
|
|
client:
|
|
request:
|
|
method: Post,
|
|
url: "http://{addr}/empty",
|
|
headers: [
|
|
ContentLength(0),
|
|
],
|
|
body: Some(""),
|
|
proxy: false,
|
|
response:
|
|
status: Ok,
|
|
headers: [],
|
|
body: None,
|
|
}
|
|
|
|
test! {
|
|
name: client_http_proxy,
|
|
|
|
server:
|
|
expected: "\
|
|
GET http://{addr}/proxy HTTP/1.1\r\n\
|
|
Host: {addr}\r\n\
|
|
\r\n\
|
|
",
|
|
reply: REPLY_OK,
|
|
|
|
client:
|
|
request:
|
|
method: Get,
|
|
url: "http://{addr}/proxy",
|
|
headers: [],
|
|
body: None,
|
|
proxy: true,
|
|
response:
|
|
status: Ok,
|
|
headers: [],
|
|
body: None,
|
|
}
|
|
|
|
|
|
test! {
|
|
name: client_head_ignores_body,
|
|
|
|
server:
|
|
expected: "\
|
|
HEAD /head HTTP/1.1\r\n\
|
|
Host: {addr}\r\n\
|
|
\r\n\
|
|
",
|
|
reply: "\
|
|
HTTP/1.1 200 OK\r\n\
|
|
Content-Length: 11\r\n\
|
|
\r\n\
|
|
Hello World\
|
|
",
|
|
|
|
client:
|
|
request:
|
|
method: Head,
|
|
url: "http://{addr}/head",
|
|
headers: [],
|
|
body: None,
|
|
proxy: false,
|
|
response:
|
|
status: Ok,
|
|
headers: [],
|
|
body: None,
|
|
}
|
|
|
|
test! {
|
|
name: client_pipeline_responses_extra,
|
|
|
|
server:
|
|
expected: "\
|
|
GET /pipe HTTP/1.1\r\n\
|
|
Host: {addr}\r\n\
|
|
\r\n\
|
|
",
|
|
reply: "\
|
|
HTTP/1.1 200 OK\r\n\
|
|
Content-Length: 0\r\n\
|
|
\r\n\
|
|
HTTP/1.1 200 OK\r\n\
|
|
Content-Length: 0\r\n\
|
|
\r\n\
|
|
",
|
|
|
|
client:
|
|
request:
|
|
method: Get,
|
|
url: "http://{addr}/pipe",
|
|
headers: [],
|
|
body: None,
|
|
proxy: false,
|
|
response:
|
|
status: Ok,
|
|
headers: [],
|
|
body: None,
|
|
}
|
|
|
|
|
|
test! {
|
|
name: client_error_unexpected_eof,
|
|
|
|
server:
|
|
expected: "\
|
|
GET /err HTTP/1.1\r\n\
|
|
Host: {addr}\r\n\
|
|
\r\n\
|
|
",
|
|
reply: "\
|
|
HTTP/1.1 200 OK\r\n\
|
|
", // unexpected eof before double CRLF
|
|
|
|
client:
|
|
request:
|
|
method: Get,
|
|
url: "http://{addr}/err",
|
|
headers: [],
|
|
body: None,
|
|
proxy: false,
|
|
error: |err| match err {
|
|
&hyper::Error::Incomplete => true,
|
|
_ => false,
|
|
},
|
|
}
|
|
|
|
test! {
|
|
name: client_error_parse_version,
|
|
|
|
server:
|
|
expected: "\
|
|
GET /err HTTP/1.1\r\n\
|
|
Host: {addr}\r\n\
|
|
\r\n\
|
|
",
|
|
reply: "\
|
|
HEAT/1.1 200 OK\r\n\
|
|
\r\n\
|
|
",
|
|
|
|
client:
|
|
request:
|
|
method: Get,
|
|
url: "http://{addr}/err",
|
|
headers: [],
|
|
body: None,
|
|
proxy: false,
|
|
error: |err| match err {
|
|
&hyper::Error::Version => true,
|
|
_ => false,
|
|
},
|
|
|
|
}
|
|
|
|
test! {
|
|
name: client_100_continue,
|
|
|
|
server:
|
|
expected: "\
|
|
POST /continue HTTP/1.1\r\n\
|
|
Host: {addr}\r\n\
|
|
Content-Length: 7\r\n\
|
|
\r\n\
|
|
foo bar\
|
|
",
|
|
reply: "\
|
|
HTTP/1.1 100 Continue\r\n\
|
|
\r\n\
|
|
HTTP/1.1 200 OK\r\n\
|
|
Content-Length: 0\r\n\
|
|
\r\n\
|
|
",
|
|
|
|
client:
|
|
request:
|
|
method: Post,
|
|
url: "http://{addr}/continue",
|
|
headers: [
|
|
ContentLength(7),
|
|
],
|
|
body: Some("foo bar"),
|
|
proxy: false,
|
|
response:
|
|
status: Ok,
|
|
headers: [],
|
|
body: None,
|
|
}
|
|
|
|
|
|
test! {
|
|
name: client_101_upgrade,
|
|
|
|
server:
|
|
expected: "\
|
|
GET /upgrade HTTP/1.1\r\n\
|
|
Host: {addr}\r\n\
|
|
\r\n\
|
|
",
|
|
reply: "\
|
|
HTTP/1.1 101 Switching Protocols\r\n\
|
|
Upgrade: websocket\r\n\
|
|
Connection: upgrade\r\n\
|
|
\r\n\
|
|
",
|
|
|
|
client:
|
|
request:
|
|
method: Get,
|
|
url: "http://{addr}/upgrade",
|
|
headers: [],
|
|
body: None,
|
|
proxy: false,
|
|
error: |err| match err {
|
|
&hyper::Error::Upgrade => true,
|
|
_ => false,
|
|
},
|
|
|
|
}
|
|
|
|
test! {
|
|
name: client_connect_method,
|
|
|
|
server:
|
|
expected: "\
|
|
CONNECT {addr} HTTP/1.1\r\n\
|
|
Host: {addr}\r\n\
|
|
\r\n\
|
|
",
|
|
// won't ever get to reply
|
|
reply: "",
|
|
|
|
client:
|
|
request:
|
|
method: Connect,
|
|
url: "http://{addr}/",
|
|
headers: [],
|
|
body: None,
|
|
proxy: false,
|
|
error: |err| match err {
|
|
&hyper::Error::Method => true,
|
|
_ => false,
|
|
},
|
|
|
|
}
|
|
|
|
test! {
|
|
name: client_set_host_false,
|
|
|
|
server:
|
|
// {addr} is here because format! requires it to exist in the string
|
|
expected: "\
|
|
GET /no-host/{addr} HTTP/1.1\r\n\
|
|
\r\n\
|
|
",
|
|
reply: "\
|
|
HTTP/1.1 200 OK\r\n\
|
|
Content-Length: 0\r\n\
|
|
\r\n\
|
|
",
|
|
|
|
client:
|
|
set_host: false,
|
|
request:
|
|
method: Get,
|
|
url: "http://{addr}/no-host/{addr}",
|
|
headers: [],
|
|
body: None,
|
|
proxy: false,
|
|
response:
|
|
status: Ok,
|
|
headers: [],
|
|
body: None,
|
|
}
|
|
|
|
#[test]
|
|
fn client_keep_alive() {
|
|
let server = TcpListener::bind("127.0.0.1:0").unwrap();
|
|
let addr = server.local_addr().unwrap();
|
|
let mut core = Core::new().unwrap();
|
|
let client = client(&core.handle());
|
|
|
|
|
|
let (tx1, rx1) = oneshot::channel();
|
|
let (tx2, rx2) = oneshot::channel();
|
|
thread::spawn(move || {
|
|
let mut sock = server.accept().unwrap().0;
|
|
sock.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
sock.set_write_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
let mut buf = [0; 4096];
|
|
sock.read(&mut buf).expect("read 1");
|
|
sock.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n").expect("write 1");
|
|
let _ = tx1.send(());
|
|
|
|
let n2 = sock.read(&mut buf).expect("read 2");
|
|
assert_ne!(n2, 0);
|
|
let second_get = "GET /b HTTP/1.1\r\n";
|
|
assert_eq!(s(&buf[..second_get.len()]), second_get);
|
|
sock.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n").expect("write 2");
|
|
let _ = tx2.send(());
|
|
});
|
|
|
|
|
|
|
|
let rx = rx1.map_err(|_| hyper::Error::Io(io::Error::new(io::ErrorKind::Other, "thread panicked")));
|
|
let res = client.get(format!("http://{}/a", addr).parse().unwrap());
|
|
core.run(res.join(rx).map(|r| r.0)).unwrap();
|
|
|
|
let rx = rx2.map_err(|_| hyper::Error::Io(io::Error::new(io::ErrorKind::Other, "thread panicked")));
|
|
let res = client.get(format!("http://{}/b", addr).parse().unwrap());
|
|
core.run(res.join(rx).map(|r| r.0)).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn client_keep_alive_extra_body() {
|
|
let _ = pretty_env_logger::try_init();
|
|
let server = TcpListener::bind("127.0.0.1:0").unwrap();
|
|
let addr = server.local_addr().unwrap();
|
|
let mut core = Core::new().unwrap();
|
|
let client = client(&core.handle());
|
|
|
|
|
|
let (tx1, rx1) = oneshot::channel();
|
|
let (tx2, rx2) = oneshot::channel();
|
|
thread::spawn(move || {
|
|
let mut sock = server.accept().unwrap().0;
|
|
sock.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
sock.set_write_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
let mut buf = [0; 4096];
|
|
sock.read(&mut buf).expect("read 1");
|
|
sock.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\nhello").expect("write 1");
|
|
// the body "hello", while ignored because its a HEAD request, should mean the connection
|
|
// cannot be put back in the pool
|
|
let _ = tx1.send(());
|
|
|
|
let mut sock2 = server.accept().unwrap().0;
|
|
let n2 = sock2.read(&mut buf).expect("read 2");
|
|
assert_ne!(n2, 0);
|
|
let second_get = "GET /b HTTP/1.1\r\n";
|
|
assert_eq!(s(&buf[..second_get.len()]), second_get);
|
|
sock2.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n").expect("write 2");
|
|
let _ = tx2.send(());
|
|
});
|
|
|
|
|
|
|
|
let rx = rx1.map_err(|_| hyper::Error::Io(io::Error::new(io::ErrorKind::Other, "thread panicked")));
|
|
let req = Request::new(Method::Head, format!("http://{}/a", addr).parse().unwrap());
|
|
let res = client.request(req);
|
|
core.run(res.join(rx).map(|r| r.0)).unwrap();
|
|
|
|
let rx = rx2.map_err(|_| hyper::Error::Io(io::Error::new(io::ErrorKind::Other, "thread panicked")));
|
|
let res = client.get(format!("http://{}/b", addr).parse().unwrap());
|
|
core.run(res.join(rx).map(|r| r.0)).unwrap();
|
|
}
|
|
|
|
mod dispatch_impl {
|
|
use super::*;
|
|
use std::io::{self, Read, Write};
|
|
use std::sync::Arc;
|
|
use std::sync::atomic::{AtomicUsize, Ordering};
|
|
use std::thread;
|
|
use std::time::Duration;
|
|
|
|
use futures::{self, Future};
|
|
use futures::sync::{mpsc, oneshot};
|
|
use tokio_core::reactor::{Timeout};
|
|
use tokio_core::net::TcpStream;
|
|
use tokio_io::{AsyncRead, AsyncWrite};
|
|
|
|
use hyper::client::HttpConnector;
|
|
use hyper::server::Service;
|
|
use hyper::{Client, Uri};
|
|
use hyper;
|
|
|
|
|
|
|
|
#[test]
|
|
fn drop_body_before_eof_closes_connection() {
|
|
// https://github.com/hyperium/hyper/issues/1353
|
|
let _ = pretty_env_logger::try_init();
|
|
|
|
let server = TcpListener::bind("127.0.0.1:0").unwrap();
|
|
let addr = server.local_addr().unwrap();
|
|
let mut core = Core::new().unwrap();
|
|
let handle = core.handle();
|
|
let (closes_tx, closes) = mpsc::channel(10);
|
|
let client = Client::configure()
|
|
.connector(DebugConnector::with_http_and_closes(HttpConnector::new(1, &core.handle()), closes_tx))
|
|
.build(&handle);
|
|
|
|
let (tx1, rx1) = oneshot::channel();
|
|
|
|
thread::spawn(move || {
|
|
let mut sock = server.accept().unwrap().0;
|
|
sock.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
sock.set_write_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
let mut buf = [0; 4096];
|
|
sock.read(&mut buf).expect("read 1");
|
|
let body = vec![b'x'; 1024 * 128];
|
|
write!(sock, "HTTP/1.1 200 OK\r\nContent-Length: {}\r\n\r\n", body.len()).expect("write head");
|
|
let _ = sock.write_all(&body);
|
|
let _ = tx1.send(());
|
|
});
|
|
|
|
let uri = format!("http://{}/a", addr).parse().unwrap();
|
|
|
|
let res = client.get(uri).and_then(move |res| {
|
|
assert_eq!(res.status(), hyper::StatusCode::Ok);
|
|
Timeout::new(Duration::from_secs(1), &handle).unwrap()
|
|
.from_err()
|
|
});
|
|
let rx = rx1.map_err(|_| hyper::Error::Io(io::Error::new(io::ErrorKind::Other, "thread panicked")));
|
|
core.run(res.join(rx).map(|r| r.0)).unwrap();
|
|
|
|
core.run(closes.into_future()).unwrap().0.expect("closes");
|
|
}
|
|
|
|
#[test]
|
|
fn dropped_client_closes_connection() {
|
|
// https://github.com/hyperium/hyper/issues/1353
|
|
let _ = pretty_env_logger::try_init();
|
|
|
|
let server = TcpListener::bind("127.0.0.1:0").unwrap();
|
|
let addr = server.local_addr().unwrap();
|
|
let mut core = Core::new().unwrap();
|
|
let handle = core.handle();
|
|
let (closes_tx, closes) = mpsc::channel(10);
|
|
|
|
let (tx1, rx1) = oneshot::channel();
|
|
|
|
thread::spawn(move || {
|
|
let mut sock = server.accept().unwrap().0;
|
|
sock.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
sock.set_write_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
let mut buf = [0; 4096];
|
|
sock.read(&mut buf).expect("read 1");
|
|
let body =[b'x'; 64];
|
|
write!(sock, "HTTP/1.1 200 OK\r\nContent-Length: {}\r\n\r\n", body.len()).expect("write head");
|
|
let _ = sock.write_all(&body);
|
|
let _ = tx1.send(());
|
|
});
|
|
|
|
let uri = format!("http://{}/a", addr).parse().unwrap();
|
|
|
|
let res = {
|
|
let client = Client::configure()
|
|
.connector(DebugConnector::with_http_and_closes(HttpConnector::new(1, &handle), closes_tx))
|
|
.build(&handle);
|
|
client.get(uri).and_then(move |res| {
|
|
assert_eq!(res.status(), hyper::StatusCode::Ok);
|
|
res.body().concat2()
|
|
}).and_then(|_| {
|
|
Timeout::new(Duration::from_secs(1), &handle).unwrap()
|
|
.from_err()
|
|
})
|
|
};
|
|
// client is dropped
|
|
let rx = rx1.map_err(|_| hyper::Error::Io(io::Error::new(io::ErrorKind::Other, "thread panicked")));
|
|
core.run(res.join(rx).map(|r| r.0)).unwrap();
|
|
|
|
core.run(closes.into_future()).unwrap().0.expect("closes");
|
|
}
|
|
|
|
|
|
#[test]
|
|
fn drop_client_closes_idle_connections() {
|
|
let _ = pretty_env_logger::try_init();
|
|
|
|
let server = TcpListener::bind("127.0.0.1:0").unwrap();
|
|
let addr = server.local_addr().unwrap();
|
|
let mut core = Core::new().unwrap();
|
|
let handle = core.handle();
|
|
let (closes_tx, mut closes) = mpsc::channel(10);
|
|
|
|
let (tx1, rx1) = oneshot::channel();
|
|
let (_client_drop_tx, client_drop_rx) = oneshot::channel::<()>();
|
|
|
|
thread::spawn(move || {
|
|
let mut sock = server.accept().unwrap().0;
|
|
sock.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
sock.set_write_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
let mut buf = [0; 4096];
|
|
sock.read(&mut buf).expect("read 1");
|
|
let body =[b'x'; 64];
|
|
write!(sock, "HTTP/1.1 200 OK\r\nContent-Length: {}\r\n\r\n", body.len()).expect("write head");
|
|
let _ = sock.write_all(&body);
|
|
let _ = tx1.send(());
|
|
|
|
// prevent this thread from closing until end of test, so the connection
|
|
// stays open and idle until Client is dropped
|
|
let _ = client_drop_rx.wait();
|
|
});
|
|
|
|
let uri = format!("http://{}/a", addr).parse().unwrap();
|
|
|
|
let client = Client::configure()
|
|
.connector(DebugConnector::with_http_and_closes(HttpConnector::new(1, &handle), closes_tx))
|
|
.build(&handle);
|
|
let res = client.get(uri).and_then(move |res| {
|
|
assert_eq!(res.status(), hyper::StatusCode::Ok);
|
|
res.body().concat2()
|
|
});
|
|
let rx = rx1.map_err(|_| hyper::Error::Io(io::Error::new(io::ErrorKind::Other, "thread panicked")));
|
|
core.run(res.join(rx).map(|r| r.0)).unwrap();
|
|
|
|
// not closed yet, just idle
|
|
{
|
|
futures::future::poll_fn(|| {
|
|
assert!(closes.poll()?.is_not_ready());
|
|
Ok::<_, ()>(().into())
|
|
}).wait().unwrap();
|
|
}
|
|
drop(client);
|
|
|
|
let t = Timeout::new(Duration::from_millis(100), &handle).unwrap()
|
|
.map(|_| panic!("time out"));
|
|
let close = closes.into_future()
|
|
.map(|(opt, _)| {
|
|
opt.expect("closes");
|
|
})
|
|
.map_err(|_| panic!("closes dropped"));
|
|
let _ = core.run(t.select(close));
|
|
}
|
|
|
|
|
|
#[test]
|
|
fn drop_response_future_closes_in_progress_connection() {
|
|
let _ = pretty_env_logger::try_init();
|
|
|
|
let server = TcpListener::bind("127.0.0.1:0").unwrap();
|
|
let addr = server.local_addr().unwrap();
|
|
let mut core = Core::new().unwrap();
|
|
let handle = core.handle();
|
|
let (closes_tx, closes) = mpsc::channel(10);
|
|
|
|
let (tx1, rx1) = oneshot::channel();
|
|
let (_client_drop_tx, client_drop_rx) = oneshot::channel::<()>();
|
|
|
|
thread::spawn(move || {
|
|
let mut sock = server.accept().unwrap().0;
|
|
sock.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
sock.set_write_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
let mut buf = [0; 4096];
|
|
sock.read(&mut buf).expect("read 1");
|
|
// we never write a response head
|
|
// simulates a slow server operation
|
|
let _ = tx1.send(());
|
|
|
|
// prevent this thread from closing until end of test, so the connection
|
|
// stays open and idle until Client is dropped
|
|
let _ = client_drop_rx.wait();
|
|
});
|
|
|
|
let uri = format!("http://{}/a", addr).parse().unwrap();
|
|
|
|
let res = {
|
|
let client = Client::configure()
|
|
.connector(DebugConnector::with_http_and_closes(HttpConnector::new(1, &handle), closes_tx))
|
|
.build(&handle);
|
|
client.get(uri)
|
|
};
|
|
|
|
//let rx = rx1.map_err(|_| hyper::Error::Io(io::Error::new(io::ErrorKind::Other, "thread panicked")));
|
|
core.run(res.select2(rx1)).unwrap();
|
|
// res now dropped
|
|
let t = Timeout::new(Duration::from_millis(100), &handle).unwrap()
|
|
.map(|_| panic!("time out"));
|
|
let close = closes.into_future()
|
|
.map(|(opt, _)| {
|
|
opt.expect("closes");
|
|
})
|
|
.map_err(|_| panic!("closes dropped"));
|
|
let _ = core.run(t.select(close));
|
|
}
|
|
|
|
#[test]
|
|
fn drop_response_body_closes_in_progress_connection() {
|
|
let _ = pretty_env_logger::try_init();
|
|
|
|
let server = TcpListener::bind("127.0.0.1:0").unwrap();
|
|
let addr = server.local_addr().unwrap();
|
|
let mut core = Core::new().unwrap();
|
|
let handle = core.handle();
|
|
let (closes_tx, closes) = mpsc::channel(10);
|
|
|
|
let (tx1, rx1) = oneshot::channel();
|
|
let (_client_drop_tx, client_drop_rx) = oneshot::channel::<()>();
|
|
|
|
thread::spawn(move || {
|
|
let mut sock = server.accept().unwrap().0;
|
|
sock.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
sock.set_write_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
let mut buf = [0; 4096];
|
|
sock.read(&mut buf).expect("read 1");
|
|
write!(sock, "HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n").expect("write head");
|
|
let _ = tx1.send(());
|
|
|
|
// prevent this thread from closing until end of test, so the connection
|
|
// stays open and idle until Client is dropped
|
|
let _ = client_drop_rx.wait();
|
|
});
|
|
|
|
let uri = format!("http://{}/a", addr).parse().unwrap();
|
|
|
|
let res = {
|
|
let client = Client::configure()
|
|
.connector(DebugConnector::with_http_and_closes(HttpConnector::new(1, &handle), closes_tx))
|
|
.build(&handle);
|
|
// notably, havent read body yet
|
|
client.get(uri)
|
|
};
|
|
|
|
let rx = rx1.map_err(|_| hyper::Error::Io(io::Error::new(io::ErrorKind::Other, "thread panicked")));
|
|
core.run(res.join(rx).map(|r| r.0)).unwrap();
|
|
|
|
let t = Timeout::new(Duration::from_millis(100), &handle).unwrap()
|
|
.map(|_| panic!("time out"));
|
|
let close = closes.into_future()
|
|
.map(|(opt, _)| {
|
|
opt.expect("closes");
|
|
})
|
|
.map_err(|_| panic!("closes dropped"));
|
|
let _ = core.run(t.select(close));
|
|
}
|
|
|
|
#[test]
|
|
fn no_keep_alive_closes_connection() {
|
|
// https://github.com/hyperium/hyper/issues/1383
|
|
let _ = pretty_env_logger::try_init();
|
|
|
|
let server = TcpListener::bind("127.0.0.1:0").unwrap();
|
|
let addr = server.local_addr().unwrap();
|
|
let mut core = Core::new().unwrap();
|
|
let handle = core.handle();
|
|
let (closes_tx, closes) = mpsc::channel(10);
|
|
|
|
let (tx1, rx1) = oneshot::channel();
|
|
|
|
thread::spawn(move || {
|
|
let mut sock = server.accept().unwrap().0;
|
|
sock.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
sock.set_write_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
let mut buf = [0; 4096];
|
|
sock.read(&mut buf).expect("read 1");
|
|
sock.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n").unwrap();
|
|
let _ = tx1.send(());
|
|
});
|
|
|
|
let uri = format!("http://{}/a", addr).parse().unwrap();
|
|
|
|
let client = Client::configure()
|
|
.connector(DebugConnector::with_http_and_closes(HttpConnector::new(1, &handle), closes_tx))
|
|
.keep_alive(false)
|
|
.build(&handle);
|
|
let res = client.get(uri).and_then(move |res| {
|
|
assert_eq!(res.status(), hyper::StatusCode::Ok);
|
|
res.body().concat2()
|
|
});
|
|
let rx = rx1.map_err(|_| hyper::Error::Io(io::Error::new(io::ErrorKind::Other, "thread panicked")));
|
|
core.run(res.join(rx).map(|r| r.0)).unwrap();
|
|
|
|
let t = Timeout::new(Duration::from_millis(100), &handle).unwrap()
|
|
.map(|_| panic!("time out"));
|
|
let close = closes.into_future()
|
|
.map(|(opt, _)| {
|
|
opt.expect("closes");
|
|
})
|
|
.map_err(|_| panic!("closes dropped"));
|
|
let _ = core.run(t.select(close));
|
|
}
|
|
|
|
#[test]
|
|
fn socket_disconnect_closes_idle_conn() {
|
|
// notably when keep-alive is enabled
|
|
let _ = pretty_env_logger::try_init();
|
|
|
|
let server = TcpListener::bind("127.0.0.1:0").unwrap();
|
|
let addr = server.local_addr().unwrap();
|
|
let mut core = Core::new().unwrap();
|
|
let handle = core.handle();
|
|
let (closes_tx, closes) = mpsc::channel(10);
|
|
|
|
let (tx1, rx1) = oneshot::channel();
|
|
|
|
thread::spawn(move || {
|
|
let mut sock = server.accept().unwrap().0;
|
|
sock.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
sock.set_write_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
let mut buf = [0; 4096];
|
|
sock.read(&mut buf).expect("read 1");
|
|
sock.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n").unwrap();
|
|
let _ = tx1.send(());
|
|
});
|
|
|
|
let uri = format!("http://{}/a", addr).parse().unwrap();
|
|
|
|
let client = Client::configure()
|
|
.connector(DebugConnector::with_http_and_closes(HttpConnector::new(1, &handle), closes_tx))
|
|
.build(&handle);
|
|
let res = client.get(uri).and_then(move |res| {
|
|
assert_eq!(res.status(), hyper::StatusCode::Ok);
|
|
res.body().concat2()
|
|
});
|
|
let rx = rx1.map_err(|_| hyper::Error::Io(io::Error::new(io::ErrorKind::Other, "thread panicked")));
|
|
core.run(res.join(rx).map(|r| r.0)).unwrap();
|
|
|
|
|
|
let t = Timeout::new(Duration::from_millis(100), &handle).unwrap()
|
|
.map(|_| panic!("time out"));
|
|
let close = closes.into_future()
|
|
.map(|(opt, _)| {
|
|
opt.expect("closes");
|
|
})
|
|
.map_err(|_| panic!("closes dropped"));
|
|
let _ = core.run(t.select(close));
|
|
}
|
|
|
|
#[test]
|
|
fn conn_drop_prevents_pool_checkout() {
|
|
// a drop might happen for any sort of reason, and we can protect
|
|
// against a lot of them, but if the `Core` is dropped, we can't
|
|
// really catch that. So, this is case to always check.
|
|
//
|
|
// See https://github.com/hyperium/hyper/issues/1429
|
|
|
|
use std::error::Error;
|
|
let _ = pretty_env_logger::try_init();
|
|
|
|
let server = TcpListener::bind("127.0.0.1:0").unwrap();
|
|
let addr = server.local_addr().unwrap();
|
|
let mut core = Core::new().unwrap();
|
|
let handle = core.handle();
|
|
|
|
let (tx1, rx1) = oneshot::channel();
|
|
|
|
thread::spawn(move || {
|
|
let mut sock = server.accept().unwrap().0;
|
|
sock.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
sock.set_write_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
let mut buf = [0; 4096];
|
|
sock.read(&mut buf).expect("read 1");
|
|
sock.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n").unwrap();
|
|
sock.read(&mut buf).expect("read 2");
|
|
let _ = tx1.send(());
|
|
});
|
|
|
|
let uri = format!("http://{}/a", addr).parse::<hyper::Uri>().unwrap();
|
|
|
|
let client = Client::new(&handle);
|
|
let res = client.get(uri.clone()).and_then(move |res| {
|
|
assert_eq!(res.status(), hyper::StatusCode::Ok);
|
|
res.body().concat2()
|
|
});
|
|
|
|
core.run(res).unwrap();
|
|
|
|
// drop previous Core
|
|
core = Core::new().unwrap();
|
|
let timeout = Timeout::new(Duration::from_millis(200), &core.handle()).unwrap();
|
|
let rx = rx1.map_err(|_| hyper::Error::Io(io::Error::new(io::ErrorKind::Other, "thread panicked")));
|
|
let rx = rx.and_then(move |_| timeout.map_err(|e| e.into()));
|
|
|
|
let res = client.get(uri);
|
|
// this does trigger an 'event loop gone' error, but before, it would
|
|
// panic internally on a `SendError`, which is what we're testing against.
|
|
let err = core.run(res.join(rx).map(|r| r.0)).unwrap_err();
|
|
assert_eq!(err.description(), "event loop gone");
|
|
}
|
|
|
|
#[test]
|
|
fn client_custom_executor() {
|
|
let server = TcpListener::bind("127.0.0.1:0").unwrap();
|
|
let addr = server.local_addr().unwrap();
|
|
let mut core = Core::new().unwrap();
|
|
let handle = core.handle();
|
|
let (closes_tx, closes) = mpsc::channel(10);
|
|
|
|
let (tx1, rx1) = oneshot::channel();
|
|
|
|
thread::spawn(move || {
|
|
let mut sock = server.accept().unwrap().0;
|
|
sock.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
sock.set_write_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
let mut buf = [0; 4096];
|
|
sock.read(&mut buf).expect("read 1");
|
|
sock.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n").unwrap();
|
|
let _ = tx1.send(());
|
|
});
|
|
|
|
let uri = format!("http://{}/a", addr).parse().unwrap();
|
|
|
|
let client = Client::configure()
|
|
.connector(DebugConnector::with_http_and_closes(HttpConnector::new(1, &handle), closes_tx))
|
|
.executor(handle.clone());
|
|
let res = client.get(uri).and_then(move |res| {
|
|
assert_eq!(res.status(), hyper::StatusCode::Ok);
|
|
res.body().concat2()
|
|
});
|
|
let rx = rx1.map_err(|_| hyper::Error::Io(io::Error::new(io::ErrorKind::Other, "thread panicked")));
|
|
|
|
let timeout = Timeout::new(Duration::from_millis(200), &handle).unwrap();
|
|
let rx = rx.and_then(move |_| timeout.map_err(|e| e.into()));
|
|
core.run(res.join(rx).map(|r| r.0)).unwrap();
|
|
|
|
|
|
let t = Timeout::new(Duration::from_millis(100), &handle).unwrap()
|
|
.map(|_| panic!("time out"));
|
|
let close = closes.into_future()
|
|
.map(|(opt, _)| {
|
|
opt.expect("closes");
|
|
})
|
|
.map_err(|_| panic!("closes dropped"));
|
|
let _ = core.run(t.select(close));
|
|
}
|
|
|
|
#[test]
|
|
fn connect_call_is_lazy() {
|
|
// We especially don't want connects() triggered if there's
|
|
// idle connections that the Checkout would have found
|
|
let _ = pretty_env_logger::try_init();
|
|
|
|
let server = TcpListener::bind("127.0.0.1:0").unwrap();
|
|
let addr = server.local_addr().unwrap();
|
|
let core = Core::new().unwrap();
|
|
let handle = core.handle();
|
|
let connector = DebugConnector::new(&handle);
|
|
let connects = connector.connects.clone();
|
|
|
|
let uri: hyper::Uri = format!("http://{}/a", addr).parse().unwrap();
|
|
|
|
let client = Client::configure()
|
|
.connector(connector)
|
|
.build(&handle);
|
|
|
|
assert_eq!(connects.load(Ordering::Relaxed), 0);
|
|
let _fut = client.get(uri);
|
|
// internal Connect::connect should have been lazy, and not
|
|
// triggered an actual connect yet.
|
|
assert_eq!(connects.load(Ordering::Relaxed), 0);
|
|
}
|
|
|
|
|
|
struct DebugConnector {
|
|
http: HttpConnector,
|
|
closes: mpsc::Sender<()>,
|
|
connects: Arc<AtomicUsize>,
|
|
}
|
|
|
|
impl DebugConnector {
|
|
fn new(handle: &Handle) -> DebugConnector {
|
|
let http = HttpConnector::new(1, handle);
|
|
let (tx, _) = mpsc::channel(10);
|
|
DebugConnector::with_http_and_closes(http, tx)
|
|
}
|
|
|
|
fn with_http_and_closes(http: HttpConnector, closes: mpsc::Sender<()>) -> DebugConnector {
|
|
DebugConnector {
|
|
http: http,
|
|
closes: closes,
|
|
connects: Arc::new(AtomicUsize::new(0)),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Service for DebugConnector {
|
|
type Request = Uri;
|
|
type Response = DebugStream;
|
|
type Error = io::Error;
|
|
type Future = Box<Future<Item = DebugStream, Error = io::Error>>;
|
|
|
|
fn call(&self, uri: Uri) -> Self::Future {
|
|
self.connects.fetch_add(1, Ordering::SeqCst);
|
|
let closes = self.closes.clone();
|
|
Box::new(self.http.call(uri).map(move |s| {
|
|
DebugStream(s, closes)
|
|
}))
|
|
}
|
|
}
|
|
|
|
struct DebugStream(TcpStream, mpsc::Sender<()>);
|
|
|
|
impl Drop for DebugStream {
|
|
fn drop(&mut self) {
|
|
let _ = self.1.try_send(());
|
|
}
|
|
}
|
|
|
|
impl Write for DebugStream {
|
|
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
|
|
self.0.write(buf)
|
|
}
|
|
|
|
fn flush(&mut self) -> io::Result<()> {
|
|
self.0.flush()
|
|
}
|
|
}
|
|
|
|
impl AsyncWrite for DebugStream {
|
|
fn shutdown(&mut self) -> futures::Poll<(), io::Error> {
|
|
AsyncWrite::shutdown(&mut self.0)
|
|
}
|
|
}
|
|
|
|
impl Read for DebugStream {
|
|
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
|
|
self.0.read(buf)
|
|
}
|
|
}
|
|
|
|
impl AsyncRead for DebugStream {}
|
|
}
|
|
|
|
mod conn {
|
|
use std::io::{self, Read, Write};
|
|
use std::net::TcpListener;
|
|
use std::thread;
|
|
use std::time::Duration;
|
|
|
|
use futures::{Async, Future, Poll, Stream};
|
|
use futures::future::poll_fn;
|
|
use futures::sync::oneshot;
|
|
use tokio_core::reactor::{Core, Timeout};
|
|
use tokio_core::net::TcpStream;
|
|
use tokio_io::{AsyncRead, AsyncWrite};
|
|
|
|
use hyper::{self, Method, Request};
|
|
use hyper::client::conn;
|
|
|
|
use super::s;
|
|
|
|
#[test]
|
|
fn get() {
|
|
let server = TcpListener::bind("127.0.0.1:0").unwrap();
|
|
let addr = server.local_addr().unwrap();
|
|
let mut core = Core::new().unwrap();
|
|
let handle = core.handle();
|
|
|
|
let (tx1, rx1) = oneshot::channel();
|
|
|
|
thread::spawn(move || {
|
|
let mut sock = server.accept().unwrap().0;
|
|
sock.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
sock.set_write_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
let mut buf = [0; 4096];
|
|
let n = sock.read(&mut buf).expect("read 1");
|
|
|
|
// Notably:
|
|
// - Just a path, since just a path was set
|
|
// - No host, since no host was set
|
|
let expected = "GET /a HTTP/1.1\r\n\r\n";
|
|
assert_eq!(s(&buf[..n]), expected);
|
|
|
|
sock.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n").unwrap();
|
|
let _ = tx1.send(());
|
|
});
|
|
|
|
let tcp = core.run(TcpStream::connect(&addr, &handle)).unwrap();
|
|
|
|
let (mut client, conn) = core.run(conn::handshake(tcp)).unwrap();
|
|
|
|
handle.spawn(conn.map(|_| ()).map_err(|e| panic!("conn error: {}", e)));
|
|
|
|
let uri = "/a".parse().unwrap();
|
|
let req = Request::new(Method::Get, uri);
|
|
|
|
let res = client.send_request(req).and_then(move |res| {
|
|
assert_eq!(res.status(), hyper::StatusCode::Ok);
|
|
res.body().concat2()
|
|
});
|
|
let rx = rx1.map_err(|_| hyper::Error::Io(io::Error::new(io::ErrorKind::Other, "thread panicked")));
|
|
|
|
let timeout = Timeout::new(Duration::from_millis(200), &handle).unwrap();
|
|
let rx = rx.and_then(move |_| timeout.map_err(|e| e.into()));
|
|
core.run(res.join(rx).map(|r| r.0)).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn uri_absolute_form() {
|
|
let server = TcpListener::bind("127.0.0.1:0").unwrap();
|
|
let addr = server.local_addr().unwrap();
|
|
let mut core = Core::new().unwrap();
|
|
let handle = core.handle();
|
|
|
|
let (tx1, rx1) = oneshot::channel();
|
|
|
|
thread::spawn(move || {
|
|
let mut sock = server.accept().unwrap().0;
|
|
sock.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
sock.set_write_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
let mut buf = [0; 4096];
|
|
let n = sock.read(&mut buf).expect("read 1");
|
|
|
|
// Notably:
|
|
// - Still no Host header, since it wasn't set
|
|
let expected = "GET http://hyper.local/a HTTP/1.1\r\n\r\n";
|
|
assert_eq!(s(&buf[..n]), expected);
|
|
|
|
sock.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n").unwrap();
|
|
let _ = tx1.send(());
|
|
});
|
|
|
|
let tcp = core.run(TcpStream::connect(&addr, &handle)).unwrap();
|
|
|
|
let (mut client, conn) = core.run(conn::handshake(tcp)).unwrap();
|
|
|
|
handle.spawn(conn.map(|_| ()).map_err(|e| panic!("conn error: {}", e)));
|
|
|
|
let uri = "http://hyper.local/a".parse().unwrap();
|
|
let req = Request::new(Method::Get, uri);
|
|
|
|
let res = client.send_request(req).and_then(move |res| {
|
|
assert_eq!(res.status(), hyper::StatusCode::Ok);
|
|
res.body().concat2()
|
|
});
|
|
let rx = rx1.map_err(|_| hyper::Error::Io(io::Error::new(io::ErrorKind::Other, "thread panicked")));
|
|
|
|
let timeout = Timeout::new(Duration::from_millis(200), &handle).unwrap();
|
|
let rx = rx.and_then(move |_| timeout.map_err(|e| e.into()));
|
|
core.run(res.join(rx).map(|r| r.0)).unwrap();
|
|
}
|
|
|
|
|
|
#[test]
|
|
fn pipeline() {
|
|
let server = TcpListener::bind("127.0.0.1:0").unwrap();
|
|
let addr = server.local_addr().unwrap();
|
|
let mut core = Core::new().unwrap();
|
|
let handle = core.handle();
|
|
|
|
let (tx1, rx1) = oneshot::channel();
|
|
|
|
thread::spawn(move || {
|
|
let mut sock = server.accept().unwrap().0;
|
|
sock.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
sock.set_write_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
let mut buf = [0; 4096];
|
|
sock.read(&mut buf).expect("read 1");
|
|
sock.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n").unwrap();
|
|
let _ = tx1.send(());
|
|
});
|
|
|
|
let tcp = core.run(TcpStream::connect(&addr, &handle)).unwrap();
|
|
|
|
let (mut client, conn) = core.run(conn::handshake(tcp)).unwrap();
|
|
|
|
handle.spawn(conn.map(|_| ()).map_err(|e| panic!("conn error: {}", e)));
|
|
|
|
let uri = "/a".parse().unwrap();
|
|
let req = Request::new(Method::Get, uri);
|
|
let res1 = client.send_request(req).and_then(move |res| {
|
|
assert_eq!(res.status(), hyper::StatusCode::Ok);
|
|
res.body().concat2()
|
|
});
|
|
|
|
// pipelined request will hit NotReady, and thus should return an Error::Cancel
|
|
let uri = "/b".parse().unwrap();
|
|
let req = Request::new(Method::Get, uri);
|
|
let res2 = client.send_request(req)
|
|
.then(|result| {
|
|
let err = result.expect_err("res2");
|
|
match err {
|
|
hyper::Error::Cancel(..) => (),
|
|
other => panic!("expected Cancel, found {:?}", other),
|
|
}
|
|
Ok(())
|
|
});
|
|
|
|
let rx = rx1.map_err(|_| hyper::Error::Io(io::Error::new(io::ErrorKind::Other, "thread panicked")));
|
|
|
|
let timeout = Timeout::new(Duration::from_millis(200), &handle).unwrap();
|
|
let rx = rx.and_then(move |_| timeout.map_err(|e| e.into()));
|
|
core.run(res1.join(res2).join(rx).map(|r| r.0)).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn upgrade() {
|
|
use tokio_io::io::{read_to_end, write_all};
|
|
let _ = ::pretty_env_logger::try_init();
|
|
|
|
let server = TcpListener::bind("127.0.0.1:0").unwrap();
|
|
let addr = server.local_addr().unwrap();
|
|
let mut core = Core::new().unwrap();
|
|
let handle = core.handle();
|
|
|
|
let (tx1, rx1) = oneshot::channel();
|
|
|
|
thread::spawn(move || {
|
|
let mut sock = server.accept().unwrap().0;
|
|
sock.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
sock.set_write_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
let mut buf = [0; 4096];
|
|
sock.read(&mut buf).expect("read 1");
|
|
sock.write_all(b"\
|
|
HTTP/1.1 101 Switching Protocols\r\n\
|
|
Upgrade: foobar\r\n\
|
|
\r\n\
|
|
foobar=ready\
|
|
").unwrap();
|
|
let _ = tx1.send(());
|
|
|
|
let n = sock.read(&mut buf).expect("read 2");
|
|
assert_eq!(&buf[..n], b"foo=bar");
|
|
sock.write_all(b"bar=foo").expect("write 2");
|
|
});
|
|
|
|
let tcp = core.run(TcpStream::connect(&addr, &handle)).unwrap();
|
|
|
|
let io = DebugStream {
|
|
tcp: tcp,
|
|
shutdown_called: false,
|
|
};
|
|
|
|
let (mut client, mut conn) = core.run(conn::handshake(io)).unwrap();
|
|
|
|
{
|
|
let until_upgrade = poll_fn(|| {
|
|
conn.poll_without_shutdown()
|
|
});
|
|
|
|
let uri = "/a".parse().unwrap();
|
|
let req = Request::new(Method::Get, uri);
|
|
let res = client.send_request(req).and_then(move |res| {
|
|
assert_eq!(res.status(), hyper::StatusCode::SwitchingProtocols);
|
|
assert_eq!(res.headers().get_raw("Upgrade").unwrap(), "foobar");
|
|
res.body().concat2()
|
|
});
|
|
|
|
let rx = rx1.map_err(|_| hyper::Error::Io(io::Error::new(io::ErrorKind::Other, "thread panicked")));
|
|
|
|
let timeout = Timeout::new(Duration::from_millis(200), &handle).unwrap();
|
|
let rx = rx.and_then(move |_| timeout.map_err(|e| e.into()));
|
|
core.run(until_upgrade.join(res).join(rx).map(|r| r.0)).unwrap();
|
|
|
|
// should not be ready now
|
|
core.run(poll_fn(|| {
|
|
assert!(client.poll_ready().unwrap().is_not_ready());
|
|
Ok::<_, ()>(Async::Ready(()))
|
|
})).unwrap();
|
|
}
|
|
|
|
let parts = conn.into_parts();
|
|
let io = parts.io;
|
|
let buf = parts.read_buf;
|
|
|
|
assert_eq!(buf, b"foobar=ready"[..]);
|
|
assert!(!io.shutdown_called, "upgrade shouldn't shutdown AsyncWrite");
|
|
assert!(client.poll_ready().is_err());
|
|
|
|
let io = core.run(write_all(io, b"foo=bar")).unwrap().0;
|
|
let vec = core.run(read_to_end(io, vec![])).unwrap().1;
|
|
assert_eq!(vec, b"bar=foo");
|
|
}
|
|
|
|
#[test]
|
|
fn connect_method() {
|
|
use tokio_io::io::{read_to_end, write_all};
|
|
let _ = ::pretty_env_logger::try_init();
|
|
|
|
let server = TcpListener::bind("127.0.0.1:0").unwrap();
|
|
let addr = server.local_addr().unwrap();
|
|
let mut core = Core::new().unwrap();
|
|
let handle = core.handle();
|
|
|
|
let (tx1, rx1) = oneshot::channel();
|
|
|
|
thread::spawn(move || {
|
|
let mut sock = server.accept().unwrap().0;
|
|
sock.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
sock.set_write_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
let mut buf = [0; 4096];
|
|
sock.read(&mut buf).expect("read 1");
|
|
sock.write_all(b"\
|
|
HTTP/1.1 200 OK\r\n\
|
|
\r\n\
|
|
foobar=ready\
|
|
").unwrap();
|
|
let _ = tx1.send(());
|
|
|
|
let n = sock.read(&mut buf).expect("read 2");
|
|
assert_eq!(&buf[..n], b"foo=bar", "sock read 2 bytes");
|
|
sock.write_all(b"bar=foo").expect("write 2");
|
|
});
|
|
|
|
let tcp = core.run(TcpStream::connect(&addr, &handle)).unwrap();
|
|
|
|
let io = DebugStream {
|
|
tcp: tcp,
|
|
shutdown_called: false,
|
|
};
|
|
|
|
let (mut client, mut conn) = core.run(conn::handshake(io)).unwrap();
|
|
|
|
{
|
|
let until_tunneled = poll_fn(|| {
|
|
conn.poll_without_shutdown()
|
|
});
|
|
|
|
let uri = format!("http://{}", addr).parse().unwrap();
|
|
let req = Request::new(Method::Connect, uri);
|
|
let res = client.send_request(req)
|
|
.and_then(move |res| {
|
|
assert_eq!(res.status(), hyper::StatusCode::Ok);
|
|
res.body().concat2()
|
|
})
|
|
.map(|body| {
|
|
assert_eq!(body.as_ref(), b"");
|
|
});
|
|
|
|
let rx = rx1.map_err(|_| hyper::Error::Io(io::Error::new(io::ErrorKind::Other, "thread panicked")));
|
|
|
|
let timeout = Timeout::new(Duration::from_millis(200), &handle).unwrap();
|
|
let rx = rx.and_then(move |_| timeout.map_err(|e| e.into()));
|
|
core.run(until_tunneled.join(res).join(rx).map(|r| r.0)).unwrap();
|
|
|
|
// should not be ready now
|
|
core.run(poll_fn(|| {
|
|
assert!(client.poll_ready().unwrap().is_not_ready());
|
|
Ok::<_, ()>(Async::Ready(()))
|
|
})).unwrap();
|
|
}
|
|
|
|
let parts = conn.into_parts();
|
|
let io = parts.io;
|
|
let buf = parts.read_buf;
|
|
|
|
assert_eq!(buf, b"foobar=ready"[..]);
|
|
assert!(!io.shutdown_called, "tunnel shouldn't shutdown AsyncWrite");
|
|
assert!(client.poll_ready().is_err());
|
|
|
|
let io = core.run(write_all(io, b"foo=bar")).unwrap().0;
|
|
let vec = core.run(read_to_end(io, vec![])).unwrap().1;
|
|
assert_eq!(vec, b"bar=foo");
|
|
}
|
|
|
|
struct DebugStream {
|
|
tcp: TcpStream,
|
|
shutdown_called: bool,
|
|
}
|
|
|
|
impl Write for DebugStream {
|
|
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
|
|
self.tcp.write(buf)
|
|
}
|
|
|
|
fn flush(&mut self) -> io::Result<()> {
|
|
self.tcp.flush()
|
|
}
|
|
}
|
|
|
|
impl AsyncWrite for DebugStream {
|
|
fn shutdown(&mut self) -> Poll<(), io::Error> {
|
|
self.shutdown_called = true;
|
|
AsyncWrite::shutdown(&mut self.tcp)
|
|
}
|
|
}
|
|
|
|
impl Read for DebugStream {
|
|
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
|
|
self.tcp.read(buf)
|
|
}
|
|
}
|
|
|
|
impl AsyncRead for DebugStream {}
|
|
}
|