/// Timeout for reading the first byte of a response. This is separate from the general read
/// timeout as it is not uncommon for Bitcoin Core to be blocked waiting on UTXO cache flushes for
-/// upwards of a minute or more. Note that we always retry once when we time out, so the maximum
-/// time we allow Bitcoin Core to block for is twice this value.
-const TCP_STREAM_RESPONSE_TIMEOUT: Duration = Duration::from_secs(120);
+/// upwards of 10 minutes on slow devices (e.g. RPis with SSDs over USB). Note that we always retry
+/// once when we time out, so the maximum time we allow Bitcoin Core to block for is twice this
+/// value.
+const TCP_STREAM_RESPONSE_TIMEOUT: Duration = Duration::from_secs(300);
/// Maximum HTTP message header size in bytes.
const MAX_HTTP_MESSAGE_HEADER_SIZE: usize = 8192;
HttpMessageLength::Empty => { Vec::new() },
HttpMessageLength::ContentLength(length) => {
if length == 0 || length > MAX_HTTP_MESSAGE_BODY_SIZE {
- return Err(std::io::Error::new(std::io::ErrorKind::InvalidData, "out of range"))
+ return Err(std::io::Error::new(std::io::ErrorKind::InvalidData, format!("invalid response length: {} bytes", length)));
} else {
let mut content = vec![0; length];
#[cfg(feature = "tokio")]
#[test]
fn convert_to_socket_addrs() {
- let endpoint = HttpEndpoint::for_host("foo.com".into());
+ let endpoint = HttpEndpoint::for_host("localhost".into());
let host = endpoint.host();
let port = endpoint.port();
use std::net::ToSocketAddrs;
match (&endpoint).to_socket_addrs() {
Err(e) => panic!("Unexpected error: {:?}", e),
- Ok(mut socket_addrs) => {
- match socket_addrs.next() {
- None => panic!("Expected socket address"),
- Some(addr) => {
- assert_eq!(addr, (host, port).to_socket_addrs().unwrap().next().unwrap());
- assert!(socket_addrs.next().is_none());
- }
+ Ok(socket_addrs) => {
+ let mut std_addrs = (host, port).to_socket_addrs().unwrap();
+ for addr in socket_addrs {
+ assert_eq!(addr, std_addrs.next().unwrap());
}
+ assert!(std_addrs.next().is_none());
}
}
}
#[test]
fn connect_to_unresolvable_host() {
match HttpClient::connect(("example.invalid", 80)) {
- Err(e) => assert_eq!(e.kind(), std::io::ErrorKind::Other),
+ Err(e) => {
+ assert!(e.to_string().contains("failed to lookup address information") ||
+ e.to_string().contains("No such host"), "{:?}", e);
+ },
Ok(_) => panic!("Expected error"),
}
}
match client.get::<BinaryResponse>("/foo", "foo.com").await {
Err(e) => {
assert_eq!(e.kind(), std::io::ErrorKind::InvalidData);
- assert_eq!(e.get_ref().unwrap().to_string(), "out of range");
+ assert_eq!(e.get_ref().unwrap().to_string(), "invalid response length: 8032001 bytes");
},
Ok(_) => panic!("Expected error"),
}