1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
|
extern crate tiny_http;
use std::io::{Cursor, Read, Write};
use std::sync::{
atomic::{
AtomicUsize,
Ordering::{AcqRel, Acquire},
},
Arc,
};
#[allow(dead_code)]
mod support;
struct MeteredReader<T> {
inner: T,
position: Arc<AtomicUsize>,
}
impl<T> Read for MeteredReader<T>
where
T: Read,
{
fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
match self.inner.read(buf) {
Ok(read) => {
self.position.fetch_add(read, AcqRel);
Ok(read)
}
e => e,
}
}
}
type Reader = MeteredReader<Cursor<String>>;
fn big_response_reader() -> Reader {
let big_body = "ABCDEFGHIJKLMNOPQRSTUVXYZ".repeat(1024 * 1024 * 16);
MeteredReader {
inner: Cursor::new(big_body),
position: Arc::new(AtomicUsize::new(0)),
}
}
fn identity_served(r: &mut Reader) -> tiny_http::Response<&mut Reader> {
let body_len = r.inner.get_ref().len();
tiny_http::Response::empty(200)
.with_chunked_threshold(std::usize::MAX)
.with_data(r, Some(body_len))
}
/// Checks that a body-Read:er is not called when the client has disconnected
#[test]
fn responding_to_closed_client() {
let (server, mut stream) = support::new_one_server_one_client();
write!(
stream,
"GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n"
)
.unwrap();
let request = server.recv().unwrap();
// Client already disconnected
drop(stream);
let mut reader = big_response_reader();
request
.respond(identity_served(&mut reader))
.expect("Successful");
assert!(reader.position.load(Acquire) < 1024 * 1024);
}
/// Checks that a slow client does not cause data to be consumed and buffered from a reader
#[test]
fn responding_to_non_consuming_client() {
let (server, mut stream) = support::new_one_server_one_client();
write!(
stream,
"GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n"
)
.unwrap();
let request = server.recv().unwrap();
let mut reader = big_response_reader();
let position = reader.position.clone();
// Client still connected, but not reading anything
std::thread::spawn(move || {
request
.respond(identity_served(&mut reader))
.expect("Successful");
});
std::thread::sleep(std::time::Duration::from_millis(100));
// It seems the client TCP socket can buffer quite a lot, so we need to be permissive
assert!(position.load(Acquire) < 8 * 1024 * 1024);
drop(stream);
}
|
