#[cfg(feature = "http2")]
use std::error::Error as StdError;
use std::sync::Arc;
use bytes::Bytes;
use crate::body::{BoxBytesStream, ResponseBody, SharedTrailers};
use crate::error::{Error, Result};
use crate::network_stream::{ConnectionMetadata, NetworkStream, UpgradedStream};
use crate::response::Response;
use crate::trace::{OnEventAction, TraceEvent, TraceObserver, TracePhase};
use crate::transport::{HyperRequestBody, TimeoutHyperClient};
pub(crate) fn emit_send_start(
trace: Option<&dyn TraceObserver>,
method: &str,
target: &str,
) -> Result<()> {
if let Some(observer) = trace {
if observer.on_event(&TraceEvent::SendRequestHeaders {
phase: TracePhase::Started,
method: method.to_owned(),
target: target.to_owned(),
}) == 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(),
});
}
}
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();
let resp_version = hyper_response.version();
let resp_headers = hyper_response.headers().clone();
emit_receive_complete(trace, status);
let on_upgrade = hyper::upgrade::on(&mut hyper_response);
let upgrading = is_upgrade_status(status);
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(hyper_response.into_body(), 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
}
pub(crate) async fn send_request(
hyper_client: &TimeoutHyperClient,
request: http::Request<HyperRequestBody>,
url: url::Url,
trace: Option<&dyn TraceObserver>,
) -> Result<Response> {
emit_send_start(trace, request.method().as_str(), &request.uri().to_string())?;
let result = hyper_client.request(request).await.map_err(map_send_error);
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_direct_request(
hyper_client: &crate::transport::TimeoutDirectClient,
request: http::Request<HyperRequestBody>,
url: url::Url,
trace: Option<&dyn TraceObserver>,
) -> Result<Response> {
emit_send_start(trace, request.method().as_str(), &request.uri().to_string())?;
let result = hyper_client.request(request).await.map_err(map_send_error);
match result {
Ok(hyper_response) => Ok(finish_hyper_response(hyper_response, url, trace).await),
Err(e) => {
emit_send_failed(trace);
Err(e)
}
}
}
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
}
}
}
pub(crate) fn upgrade_with_connector_metadata(
upgraded: hyper::upgrade::Upgraded,
) -> UpgradedStream {
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(unix)]
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)
}
}
}
}
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>> {
match Pin::new(&mut self.inner).poll_frame(cx) {
Poll::Ready(Some(Ok(frame))) => {
if frame.is_data() {
match frame.into_data() {
Ok(data) => Poll::Ready(Some(Ok(data))),
Err(_) => {
Poll::Ready(Some(Err(Error::Body("invalid data frame".into()))))
}
}
} else if frame.is_trailers() {
if let Ok(headers) = frame.into_trailers() {
self.trailers.store(headers);
#[cfg(feature = "tracing")]
tracing::debug!("eggfetch: captured HTTP trailers");
}
Poll::Ready(None)
} else {
Poll::Ready(None)
}
}
Poll::Ready(Some(Err(e))) => Poll::Ready(Some(Err(Error::Body(e.to_string())))),
Poll::Ready(None) => Poll::Ready(None),
Poll::Pending => Poll::Pending,
}
}
}
Box::pin(IncomingStream {
inner: incoming,
trailers,
})
}
pub(crate) fn map_send_error(err: hyper_util::client::legacy::Error) -> Error {
let mut current: Option<&dyn std::error::Error> = Some(&err);
while let Some(e) = current {
if let Some(hyper_err) = e.downcast_ref::<hyper::Error>() {
#[cfg(feature = "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();
}
Error::HyperClient(std::sync::Arc::new(err))
}
#[cfg(feature = "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 = "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 = "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());
}
}