use serde::de::DeserializeOwned;
use tez::{BodyExt as _, HttpBody as _};
pub(super) fn retry_after(response: &tez::Response) -> Option<std::time::Duration> {
parse_retry_after(response.headers().get("retry-after")?.to_str().ok()?)
}
fn parse_retry_after(value: &str) -> Option<std::time::Duration> {
value
.parse::<u64>()
.ok()
.map(std::time::Duration::from_secs)
}
pub(super) async fn json<T>(response: tez::Response, limit: usize) -> Result<T, ()>
where
T: DeserializeOwned,
{
let content_length = response.content_length();
decode_json(response.into_body(), content_length, limit).await
}
async fn decode_json<T>(
mut body: tez::Body,
content_length: Option<u64>,
limit: usize,
) -> Result<T, ()>
where
T: DeserializeOwned,
{
if content_length.is_some_and(|length| length > limit as u64) {
return Err(());
}
if body.size_hint().lower() > limit as u64 {
return Err(());
}
let mut bytes = Vec::new();
while let Some(frame) = body.frame().await {
let frame = frame.map_err(|_| ())?;
if let Ok(data) = frame.into_data() {
let length = bytes.len().checked_add(data.len()).ok_or(())?;
if length > limit {
return Err(());
}
bytes.extend_from_slice(&data);
}
}
serde_json::from_slice(&bytes).map_err(|_| ())
}
#[cfg(test)]
mod tests {
use futures_executor::block_on;
use serde::Deserialize;
use super::{decode_json, parse_retry_after};
#[derive(Debug, Deserialize, Eq, PartialEq)]
struct Payload {
value: String,
}
#[test]
fn retry_after_accepts_only_whole_seconds() {
assert_eq!(
parse_retry_after("42"),
Some(std::time::Duration::from_secs(42))
);
assert_eq!(parse_retry_after("tomorrow"), None);
}
#[test]
fn bounded_json_accepts_a_valid_body() {
let payload = block_on(decode_json::<Payload>(
tez::Body::from(r#"{"value":"ok"}"#),
None,
64,
));
assert_eq!(
payload,
Ok(Payload {
value: "ok".to_owned()
})
);
}
#[test]
fn bounded_json_rejects_declared_hinted_and_observed_overflow() {
let declared = block_on(decode_json::<Payload>(tez::Body::empty(), Some(65), 64));
let hinted = block_on(decode_json::<Payload>(
tez::Body::from(r#"{"value":"too long"}"#),
None,
8,
));
let body = tez::Body::stream(futures_util::stream::iter([
Ok::<_, std::io::Error>(vec![b'a'; 5]),
Ok(vec![b'b'; 5]),
]));
let observed = block_on(decode_json::<Payload>(body, None, 8));
assert_eq!(declared, Err(()));
assert_eq!(hinted, Err(()));
assert_eq!(observed, Err(()));
}
#[test]
fn bounded_json_rejects_malformed_input() {
let payload = block_on(decode_json::<Payload>(
tez::Body::from("not json"),
None,
64,
));
assert_eq!(payload, Err(()));
}
}