#[cfg(feature = "transport-http2")]
use std::error::Error as StdError;
use std::sync::Arc;
use std::time::Duration;
use bytes::Bytes;
use crate::body::{BoxBytesStream, ResponseBody, SharedTrailers};
use crate::error::{Error, Result};
use crate::network_stream::{ConnectionMetadata, NetworkStream, UpgradedStream};
#[cfg(feature = "high-level-url")]
use crate::response::Response;
use crate::trace::{OnEventAction, TraceEvent, TraceObserver, TracePhase};
use crate::transport::HyperRequestBody;
pub(crate) fn emit_send_start(
trace: Option<&dyn TraceObserver>,
method: &str,
target: &http::Uri,
) -> Result<()> {
if let Some(observer) = trace {
if observer.on_event(&TraceEvent::SendRequestHeaders {
phase: TracePhase::Started,
method: method.to_owned(),
target: target.to_string(),
}) == OnEventAction::Abort
{
return Err(Error::TraceCallbackAborted);
}
}
Ok(())
}
pub(crate) fn emit_receive_complete(trace: Option<&dyn TraceObserver>, status: u16) {
if let Some(observer) = trace {
observer.on_event(&TraceEvent::ReceiveResponseHeaders {
phase: TracePhase::Complete,
status,
});
}
}
pub(crate) fn emit_send_failed(trace: Option<&dyn TraceObserver>) {
if let Some(observer) = trace {
let _ = observer.on_event(&TraceEvent::SendRequestHeaders {
phase: TracePhase::Failed,
method: String::new(),
target: String::new(),
});
}
}
#[cfg(feature = "high-level-url")]
async fn finish_hyper_response(
mut hyper_response: http::Response<hyper::body::Incoming>,
url: url::Url,
trace: Option<&dyn TraceObserver>,
) -> Response {
let status = hyper_response.status().as_u16();
emit_receive_complete(trace, status);
let on_upgrade = hyper::upgrade::on(&mut hyper_response);
let upgrading = is_upgrade_status(status);
let (parts, incoming) = hyper_response.into_parts();
let resp_version = parts.version;
let resp_headers = parts.headers;
let mut response = if upgrading {
let body = ResponseBody::buffered(Bytes::new());
Response::new(
http::StatusCode::from_u16(status).unwrap_or(http::StatusCode::OK),
resp_version,
resp_headers,
url,
body,
)
} else {
let trailers = SharedTrailers::new();
let stream: BoxBytesStream = wrap_incoming(incoming, trailers.clone());
let body = ResponseBody::streaming(stream);
let mut response = Response::new(
http::StatusCode::from_u16(status).unwrap_or(http::StatusCode::OK),
resp_version,
resp_headers,
url,
body,
);
response.set_trailers(trailers);
response
};
if upgrading {
let upgraded = await_upgrade(on_upgrade).await;
if let Some(stream) = upgraded {
response.set_network_stream(NetworkStream::Upgraded(stream));
}
}
response
}
#[cfg(feature = "high-level-url")]
pub(crate) async fn send_request<C>(
hyper_client: &hyper_util::client::legacy::Client<C, HyperRequestBody>,
mut request: http::Request<HyperRequestBody>,
url: url::Url,
trace: Option<&dyn TraceObserver>,
failure_context: Option<&crate::error::RequestFailureContext>,
read_timeout: Option<Duration>,
remaining_total: Option<Duration>,
) -> Result<Response>
where
C: hyper_util::client::legacy::connect::Connect + Clone + Send + Sync + 'static,
{
emit_send_start(trace, request.method().as_str(), request.uri())?;
let completion = request.body_mut().take_completion_receiver();
let send = async {
hyper_client
.request(request)
.await
.map_err(|error| map_send_error_with_context(error, failure_context))
};
let result = send_with_read_timeout(send, completion, read_timeout, remaining_total).await;
match result {
Ok(hyper_response) => Ok(finish_hyper_response(hyper_response, url, trace).await),
Err(e) => {
emit_send_failed(trace);
Err(e)
}
}
}
#[cfg(feature = "proxy")]
pub(crate) async fn send_proxy_request<C>(
hyper_client: &hyper_util::client::legacy::Client<C, HyperRequestBody>,
mut request: http::Request<HyperRequestBody>,
url: url::Url,
trace: Option<&dyn TraceObserver>,
failure_context: Option<&crate::error::RequestFailureContext>,
read_timeout: Option<Duration>,
remaining_total: Option<Duration>,
) -> Result<Response>
where
C: hyper_util::client::legacy::connect::Connect + Clone + Send + Sync + 'static,
{
emit_send_start(trace, request.method().as_str(), request.uri())?;
let completion = request.body_mut().take_completion_receiver();
let send = async {
hyper_client
.request(request)
.await
.map_err(|error| map_send_error_for_proxy(error, failure_context))
};
let result = send_with_read_timeout(send, completion, read_timeout, remaining_total).await;
match result {
Ok(hyper_response) => Ok(finish_hyper_response(hyper_response, url, trace).await),
Err(error) => {
emit_send_failed(trace);
Err(error)
}
}
}
pub(crate) async fn send_raw_request<C>(
hyper_client: &hyper_util::client::legacy::Client<C, HyperRequestBody>,
mut request: http::Request<HyperRequestBody>,
trace: Option<&dyn TraceObserver>,
read_timeout: Option<Duration>,
remaining_total: Option<Duration>,
) -> Result<http::Response<hyper::body::Incoming>>
where
C: hyper_util::client::legacy::connect::Connect + Clone + Send + Sync + 'static,
{
emit_send_start(trace, request.method().as_str(), request.uri())?;
let completion = request.body_mut().take_completion_receiver();
let send = async { hyper_client.request(request).await.map_err(map_send_error) };
match send_with_read_timeout(send, completion, read_timeout, remaining_total).await {
Ok(response) => {
emit_receive_complete(trace, response.status().as_u16());
Ok(response)
}
Err(error) => {
emit_send_failed(trace);
Err(error)
}
}
}
#[cfg(feature = "high-level-url")]
pub(crate) async fn send_direct_request<C>(
hyper_client: &hyper_util::client::legacy::Client<C, HyperRequestBody>,
mut request: http::Request<HyperRequestBody>,
url: url::Url,
trace: Option<&dyn TraceObserver>,
failure_context: Option<&crate::error::RequestFailureContext>,
read_timeout: Option<Duration>,
remaining_total: Option<Duration>,
) -> Result<Response>
where
C: hyper_util::client::legacy::connect::Connect + Clone + Send + Sync + 'static,
{
emit_send_start(trace, request.method().as_str(), request.uri())?;
let completion = request.body_mut().take_completion_receiver();
let send = async {
hyper_client
.request(request)
.await
.map_err(|error| map_send_error_with_context(error, failure_context))
};
let result = send_with_read_timeout(send, completion, read_timeout, remaining_total).await;
match result {
Ok(hyper_response) => Ok(finish_hyper_response(hyper_response, url, trace).await),
Err(e) => {
emit_send_failed(trace);
Err(e)
}
}
}
pub(crate) async fn send_with_read_timeout<F, T>(
send_future: F,
completion: Option<tokio::sync::oneshot::Receiver<tokio::time::Instant>>,
read_timeout: Option<Duration>,
remaining_total: Option<Duration>,
) -> Result<T>
where
F: std::future::Future<Output = Result<T>>,
{
use crate::timeout::TimeoutPhase;
let (Some(completion), Some(read_timeout)) = (completion, read_timeout) else {
return send_future.await;
};
let started = tokio::time::Instant::now();
tokio::pin!(send_future);
tokio::pin!(completion);
let sent_at = tokio::select! {
biased;
result = &mut send_future => return result,
completed = &mut completion => match completed {
Ok(at) => at,
Err(_) => return send_future.await,
},
};
let read_deadline = sent_at + read_timeout;
let total_deadline = remaining_total.map(|remaining| started + remaining);
if total_deadline.is_some_and(|deadline| deadline <= read_deadline) {
return send_future.await;
}
if tokio::time::Instant::now() >= read_deadline {
return Err(Error::Timeout {
phase: TimeoutPhase::Read,
elapsed: tokio::time::Instant::now().saturating_duration_since(sent_at),
});
}
tokio::select! {
biased;
() = tokio::time::sleep_until(read_deadline) => Err(Error::Timeout {
phase: TimeoutPhase::Read,
elapsed: tokio::time::Instant::now().saturating_duration_since(sent_at),
}),
result = &mut send_future => {
if tokio::time::Instant::now() >= read_deadline {
Err(Error::Timeout {
phase: TimeoutPhase::Read,
elapsed: tokio::time::Instant::now().saturating_duration_since(sent_at),
})
} else {
result
}
},
}
}
pub(crate) fn is_upgrade_status(status: u16) -> bool {
status == 101
}
pub(crate) async fn await_upgrade(on_upgrade: hyper::upgrade::OnUpgrade) -> Option<UpgradedStream> {
match on_upgrade.await {
Ok(upgraded) => Some(upgrade_with_connector_metadata(upgraded)),
Err(_e) => {
None
}
}
}
#[allow(
clippy::too_many_lines,
reason = "Upgrade classification must cover direct, lifecycle-wrapped direct, UDS, and opaque Hyper branches in one exhaustive downcast path"
)]
pub(crate) fn upgrade_with_connector_metadata(
upgraded: hyper::upgrade::Upgraded,
) -> UpgradedStream {
let upgraded = match upgraded.downcast::<crate::transport::lifecycle::LifecycleConnection<
hyper_util::rt::TokioIo<crate::transport::direct_connector::DirectStream>,
>>() {
Ok(parts) => {
let (inner, permit) = parts.io.into_inner_and_permit();
let direct = inner.into_inner();
let leading = parts.read_buf;
let mut stream = match direct {
crate::transport::direct_connector::DirectStream::Tcp(tcp) => {
UpgradedStream::from_tcp(tcp, leading)
}
#[cfg(feature = "tls-rustls")]
crate::transport::direct_connector::DirectStream::Tls(tls) => {
let (_, conn) = tls.get_ref();
let tls_info = crate::network_stream::tls_info_from_rustls(conn, None);
UpgradedStream::from_tls(*tls, leading, tls_info)
}
};
if let Some(permit) = permit {
stream.hold_connection_guard(Box::new(permit));
}
return stream;
}
Err(upgraded) => upgraded,
};
match upgraded
.downcast::<hyper_util::rt::TokioIo<crate::transport::direct_connector::DirectStream>>()
{
Ok(parts) => {
let direct = parts.io.into_inner();
let leading = parts.read_buf;
match direct {
crate::transport::direct_connector::DirectStream::Tcp(tcp) => {
UpgradedStream::from_tcp(tcp, leading)
}
#[cfg(feature = "tls-rustls")]
crate::transport::direct_connector::DirectStream::Tls(tls) => {
let (_, conn) = tls.get_ref();
let tls_info = crate::network_stream::tls_info_from_rustls(conn, None);
UpgradedStream::from_tls(*tls, leading, tls_info)
}
}
}
Err(upgraded) => {
#[cfg(all(unix, feature = "advanced-routing"))]
let upgraded = match upgraded
.downcast::<crate::transport::lifecycle::LifecycleConnection<
hyper_util::rt::TokioIo<crate::transport::uds::UdsStream>,
>>() {
Ok(parts) => {
let (inner, permit) = parts.io.into_inner_and_permit();
let uds = inner.into_inner();
let leading = parts.read_buf;
let (kind, tls_info) = match &uds {
crate::transport::uds::UdsStream::Plain(_) => {
(crate::network_stream::TransportKind::Unix, None)
}
#[cfg(feature = "tls-rustls")]
crate::transport::uds::UdsStream::Tls(tls) => {
let (_, conn) = tls.get_ref();
(
crate::network_stream::TransportKind::TlsUnix,
Some(crate::network_stream::tls_info_from_rustls(conn, None)),
)
}
};
let metadata = Arc::new(ConnectionMetadata {
local_addr: None,
peer_addr: None,
transport_kind: kind,
tls_info,
});
let mut stream = UpgradedStream::from_adapter(uds, leading, metadata);
if let Some(permit) = permit {
stream.hold_connection_guard(Box::new(permit));
}
return stream;
}
Err(upgraded) => upgraded,
};
#[cfg(all(unix, feature = "advanced-routing"))]
match upgraded.downcast::<hyper_util::rt::TokioIo<crate::transport::uds::UdsStream>>() {
Ok(parts) => {
let uds = parts.io.into_inner();
let leading = parts.read_buf;
let (kind, tls_info) = match &uds {
crate::transport::uds::UdsStream::Plain(_) => {
(crate::network_stream::TransportKind::Unix, None)
}
#[cfg(feature = "tls-rustls")]
crate::transport::uds::UdsStream::Tls(tls) => {
let (_, conn) = tls.get_ref();
(
crate::network_stream::TransportKind::TlsUnix,
Some(crate::network_stream::tls_info_from_rustls(conn, None)),
)
}
};
let metadata = Arc::new(ConnectionMetadata {
local_addr: None,
peer_addr: None,
transport_kind: kind,
tls_info,
});
UpgradedStream::from_adapter(uds, leading, metadata)
}
Err(upgraded) => opaque_upgraded(upgraded),
}
#[cfg(not(unix))]
{
opaque_upgraded(upgraded)
}
#[cfg(all(unix, not(feature = "advanced-routing")))]
{
let _ = &upgraded;
opaque_upgraded(upgraded)
}
}
}
}
fn opaque_upgraded(upgraded: hyper::upgrade::Upgraded) -> UpgradedStream {
let leading = Bytes::new();
let adapter = hyper_util::rt::TokioIo::new(upgraded);
let metadata = Arc::new(ConnectionMetadata::default());
UpgradedStream::from_adapter(adapter, leading, metadata)
}
pub(crate) fn wrap_incoming(
incoming: hyper::body::Incoming,
trailers: SharedTrailers,
) -> BoxBytesStream {
use futures_core::Stream;
use http_body::Body;
use std::pin::Pin;
use std::task::{Context, Poll};
struct IncomingStream {
inner: hyper::body::Incoming,
trailers: SharedTrailers,
}
impl Stream for IncomingStream {
type Item = Result<Bytes>;
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
loop {
match Pin::new(&mut self.inner).poll_frame(cx) {
Poll::Ready(Some(Ok(frame))) => {
if frame.is_data() {
return match frame.into_data() {
Ok(data) => Poll::Ready(Some(Ok(data))),
Err(_) => {
Poll::Ready(Some(Err(Error::Body("invalid data frame".into()))))
}
};
}
if frame.is_trailers() {
if let Ok(headers) = frame.into_trailers() {
self.trailers.store(headers);
#[cfg(feature = "tracing")]
tracing::debug!("eggfetch: captured HTTP trailers");
}
return Poll::Ready(None);
}
}
Poll::Ready(Some(Err(e))) => {
return Poll::Ready(Some(Err(Error::Body(e.to_string()))));
}
Poll::Ready(None) => return Poll::Ready(None),
Poll::Pending => return Poll::Pending,
}
}
}
}
Box::pin(IncomingStream {
inner: incoming,
trailers,
})
}
pub(crate) fn map_send_error(err: hyper_util::client::legacy::Error) -> Error {
map_send_error_with_context(err, None)
}
pub(crate) fn map_send_error_with_context(
err: hyper_util::client::legacy::Error,
failure_context: Option<&crate::error::RequestFailureContext>,
) -> Error {
let mut refused = false;
let mut resolver_failed = false;
let mut current: Option<&dyn std::error::Error> = Some(&err);
for _ in 0..32 {
let Some(e) = current else { break };
if let Some(direct_error) =
e.downcast_ref::<crate::transport::direct_connector::DirectConnectError>()
{
if let Some(context) = failure_context {
context.record(match direct_error.kind() {
crate::transport::ConnectFailureKind::Dns => {
crate::error::NetworkFailureKind::Dns
}
crate::transport::ConnectFailureKind::ConnectionRefused => {
crate::error::NetworkFailureKind::ConnectionRefused
}
crate::transport::ConnectFailureKind::Connect => {
crate::error::NetworkFailureKind::Connect
}
});
}
return Error::Connect(direct_error.message().to_owned());
}
if e.downcast_ref::<crate::transport::standard_resolver::ResolverFailure>()
.is_some()
{
resolver_failed = true;
}
if let Some(core_error) = e.downcast_ref::<Error>() {
return core_error.clone();
}
if let Some(io_error) = e.downcast_ref::<std::io::Error>() {
refused |= io_error.kind() == std::io::ErrorKind::ConnectionRefused;
if let Some(inner) = io_error
.get_ref()
.and_then(|source| source.downcast_ref::<Error>())
{
return inner.clone();
}
}
if let Some(hyper_err) = e.downcast_ref::<hyper::Error>() {
#[cfg(feature = "transport-http2")]
if let Some(h2_err) = classify_h2_hyper_error(hyper_err) {
return h2_err;
}
let mut src: Option<&dyn std::error::Error> = Some(hyper_err);
while let Some(s) = src {
if let Some(body_err) = s.downcast_ref::<Error>() {
return body_err.clone();
}
src = s.source();
}
}
current = e.source();
}
if let Some(context) = failure_context {
if err.is_connect() {
context.record(if resolver_failed {
crate::error::NetworkFailureKind::Dns
} else if refused {
crate::error::NetworkFailureKind::ConnectionRefused
} else {
crate::error::NetworkFailureKind::Connect
});
}
}
Error::HyperClient(std::sync::Arc::new(err))
}
#[cfg(feature = "proxy")]
fn map_send_error_for_proxy(
err: hyper_util::client::legacy::Error,
failure_context: Option<&crate::error::RequestFailureContext>,
) -> Error {
let mut current: Option<&dyn std::error::Error> = Some(&err);
for _ in 0..32 {
let Some(error) = current else { break };
if let Some(hyper_error) = error.downcast_ref::<hyper::Error>() {
if hyper_error.is_parse() {
return Error::MalformedProxyResponse(
"proxy response could not be parsed by Hyper".into(),
);
}
}
current = error.source();
}
map_send_error_with_context(err, failure_context)
}
#[cfg(feature = "transport-http2")]
fn classify_h2_hyper_error(err: &hyper::Error) -> Option<Error> {
let msg = err.to_string();
let mut source = StdError::source(err);
while let Some(cause) = source {
if let Some(h2_err) = cause.downcast_ref::<h2::Error>() {
if h2_err.is_io() {
return None;
}
if h2_err.is_go_away() {
return Some(Error::Http2GoAway {
last_stream_id: 0,
debug_data: h2_err.to_string(),
});
}
if h2_err.is_reset() {
let reason = h2_err
.reason()
.map_or_else(|| h2_err.to_string(), |reason| reason.to_string());
return Some(Error::Http2StreamReset { reason });
}
if h2_err.reason() == Some(h2::Reason::FLOW_CONTROL_ERROR) {
return Some(Error::Http2FlowControl(h2_err.to_string()));
}
return Some(Error::Http2Protocol(h2_err.to_string()));
}
source = StdError::source(cause);
}
classify_h2_message(&msg)
}
#[cfg(feature = "transport-http2")]
fn classify_h2_message(msg: &str) -> Option<Error> {
let lower = msg.to_ascii_lowercase();
if lower.contains("goaway") || lower.contains("go away") {
return Some(Error::Http2GoAway {
last_stream_id: 0,
debug_data: msg.to_string(),
});
}
if lower.contains("rst_stream") || lower.contains("refused_stream") {
return Some(Error::Http2StreamReset {
reason: msg.to_string(),
});
}
if lower.contains("flow control") {
return Some(Error::Http2FlowControl(msg.to_string()));
}
if lower.contains("http2") || lower.contains("h2") {
return Some(Error::Http2Protocol(msg.to_string()));
}
None
}
#[cfg(all(test, feature = "transport-http2"))]
mod tests {
use super::classify_h2_message;
#[test]
fn fallback_classifies_current_hyper_h2_messages() {
assert_eq!(
classify_h2_message("http2 error: GOAWAY received: NO_ERROR")
.expect("GOAWAY marker should classify")
.kind(),
"http2_go_away"
);
assert_eq!(
classify_h2_message("http2 error: stream error received: REFUSED_STREAM")
.expect("stream reset marker should classify")
.kind(),
"http2_stream_reset"
);
assert_eq!(
classify_h2_message("http2 error: flow control window exhausted")
.expect("flow-control marker should classify")
.kind(),
"http2_flow_control"
);
}
#[test]
fn fallback_ignores_unrelated_messages() {
assert!(classify_h2_message("connection reset by peer").is_none());
}
}