use std::sync::Arc;
use std::time::Duration;
use bytes::Bytes;
use super::route::TransportRoute;
use crate::body::ResponseBody;
use crate::client::ClientInner;
use crate::error::Result;
use crate::pool::PoolGuard;
use crate::response::Response;
use crate::timeout::ResponseDeadline;
pub(super) fn apply_timeouts_and_lease(
response: &mut Response,
mut guard: PoolGuard,
read_timeout: Option<Duration>,
total_deadline: Option<ResponseDeadline>,
) {
guard.set_response_timeouts(read_timeout, total_deadline);
if !guard.has_response_state() {
drop(guard);
return;
}
let body = std::mem::replace(&mut response.body, ResponseBody::buffered(Bytes::new()));
let new_body = body.attach_lease(Arc::new(guard));
response.set_body(new_body);
}
#[allow(
clippy::too_many_arguments,
reason = "the post-transport policy takes the response, the route facts and the limit inputs explicitly so one function owns the whole finalization sequence"
)]
pub(super) fn finalize_response(
inner: &ClientInner,
mut response: Response,
route: TransportRoute,
via_proxy: bool,
decompression_enabled: bool,
max_decoded_body_size: Option<usize>,
max_decompression_ratio: Option<f64>,
guard: PoolGuard,
read_timeout: Option<Duration>,
total_deadline: Option<ResponseDeadline>,
) -> Result<Response> {
#[cfg(feature = "http3")]
{
let learnable = matches!(
route,
TransportRoute::Standard | TransportRoute::Direct | TransportRoute::H3
);
if learnable {
super::h3_dispatch::learn_altsvc_from_response(
inner,
response.url(),
response.headers(),
via_proxy,
true,
);
}
}
#[cfg(not(feature = "http3"))]
let _ = (route, via_proxy);
if response
.network_stream()
.is_some_and(crate::network_stream::NetworkStream::is_upgraded)
{
inner.transport_metrics.record_upgraded();
}
if decompression_enabled {
let content_encoding = response
.headers()
.get("content-encoding")
.and_then(|v| v.to_str().ok())
.map(str::to_owned);
let limit = crate::compression::DecompressionLimit {
max_decoded_body_size,
max_decompression_ratio,
};
response = crate::response_decode::apply_decompression(
response,
content_encoding.as_deref(),
limit,
)?;
}
if let Some(max) = max_decoded_body_size {
response.body = response.body.limit_decoded_size(max)?;
}
apply_timeouts_and_lease(&mut response, guard, read_timeout, total_deadline);
Ok(response)
}