use crate::api::error::NetError;
#[cfg(feature = "http-client-http2")]
use crate::api::http::HttpResponseInfo;
use bytes::Bytes;
use http::{HeaderMap, StatusCode};
use serde::de::DeserializeOwned;
use std::fmt;
use std::str::Utf8Error;
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct HttpRequestId(pub u64);
#[derive(Clone)]
pub struct HttpResponseHead {
pub status: StatusCode,
pub headers: HeaderMap,
}
impl fmt::Debug for HttpResponseHead {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("HttpResponseHead")
.field("status", &self.status)
.field("header_count", &self.headers.len())
.finish()
}
}
#[derive(Clone)]
pub struct HttpResponse {
#[cfg(feature = "quality-doctor")]
quality_ref: Option<crate::api::quality::QualityReportRef>,
retry_report: Option<crate::api::retry::RetryReport>,
pub status: StatusCode,
pub headers: HeaderMap,
pub body: Bytes,
pub attempts: u32,
pub request_id: HttpRequestId,
#[cfg(feature = "http-client-http2")]
info: HttpResponseInfo,
}
impl HttpResponse {
#[cfg(feature = "quality-doctor")]
pub fn quality_ref(&self) -> Option<crate::api::quality::QualityReportRef> {
self.quality_ref
}
#[cfg(feature = "quality-doctor")]
pub(crate) fn with_quality_ref(
mut self,
reference: crate::api::quality::QualityReportRef,
) -> Self {
self.quality_ref = Some(reference);
self
}
pub fn retry_report(&self) -> Option<&crate::api::retry::RetryReport> {
self.retry_report.as_ref()
}
pub(crate) fn with_retry_report(mut self, report: crate::api::retry::RetryReport) -> Self {
self.retry_report = Some(report);
self
}
pub fn content_type(&self) -> Option<&str> {
self.headers.get(http::header::CONTENT_TYPE)?.to_str().ok()
}
pub fn check_status(&self, policy: crate::api::http::HttpStatusPolicy) -> Result<(), NetError> {
if policy.accepts(self.status) {
Ok(())
} else {
let error = NetError::from_http_status(self.status);
#[cfg(feature = "quality-doctor")]
let error = match self.quality_ref {
Some(reference) => error.with_quality_ref(reference),
None => error,
};
Err(error)
}
}
pub fn new(
status: StatusCode,
headers: HeaderMap,
body: Bytes,
attempts: u32,
request_id: HttpRequestId,
) -> Self {
Self {
#[cfg(feature = "quality-doctor")]
quality_ref: None,
retry_report: None,
status,
headers,
body,
attempts,
request_id,
#[cfg(feature = "http-client-http2")]
info: HttpResponseInfo::default(),
}
}
#[cfg(feature = "http-client-http2")]
pub(crate) fn with_info(mut self, info: HttpResponseInfo) -> Self {
self.info = info;
self
}
#[cfg(feature = "http-client-http2")]
pub fn info(&self) -> &HttpResponseInfo {
&self.info
}
#[cfg(feature = "http-client-http2")]
pub fn protocol(&self) -> crate::api::http::HttpProtocol {
self.info.protocol
}
#[cfg(feature = "http-client-middleware")]
pub fn synthetic(
request_id: HttpRequestId,
status: StatusCode,
headers: HeaderMap,
body: Bytes,
) -> Self {
Self::new(status, headers, body, 0, request_id)
}
pub fn is_success(&self) -> bool {
self.status.is_success()
}
pub fn text(&self) -> Result<&str, Utf8Error> {
std::str::from_utf8(self.body.as_ref())
}
pub fn json<T: DeserializeOwned>(&self) -> Result<T, serde_json::Error> {
serde_json::from_slice(self.body.as_ref())
}
pub fn status(&self) -> StatusCode {
self.status
}
pub fn headers(&self) -> &HeaderMap {
&self.headers
}
pub fn body(&self) -> &Bytes {
&self.body
}
pub fn attempts(&self) -> u32 {
self.attempts
}
pub fn request_id(&self) -> HttpRequestId {
self.request_id
}
}
impl fmt::Debug for HttpResponse {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("HttpResponse")
.field("status", &self.status)
.field("header_count", &self.headers.len())
.field("body_bytes", &self.body.len())
.field("attempts", &self.attempts)
.field("request_id", &self.request_id)
.finish()
}
}
pub type HttpResponseResult = Result<HttpResponse, NetError>;
#[cfg(test)]
mod tests {
use super::*;
use http::HeaderValue;
type TestResult = Result<(), Box<dyn std::error::Error + Send + Sync>>;
fn check(condition: bool, message: &str) -> TestResult {
if condition {
Ok(())
} else {
Err(std::io::Error::other(message).into())
}
}
#[test]
fn response_exposes_status_body_and_json_without_leaking_body_in_debug() -> TestResult {
let mut headers = HeaderMap::new();
headers.insert("content-type", HeaderValue::from_static("application/json"));
let response = HttpResponse::new(
StatusCode::OK,
headers,
Bytes::from_static(br#"{"value":7}"#),
2,
HttpRequestId(9),
);
check(response.is_success(), "2xx response must be successful")?;
check(response.attempts() == 2, "attempt count not retained")?;
check(
response.request_id() == HttpRequestId(9),
"request id not retained",
)?;
check(response.text()? == r#"{"value":7}"#, "body text mismatch")?;
let decoded: serde_json::Value = response.json()?;
check(decoded["value"] == 7, "JSON body was not decoded")?;
check(
!format!("{response:?}").contains("value"),
"response Debug leaked body",
)
}
#[test]
fn response_result_keeps_http_failures_distinct_from_transport_errors() -> TestResult {
let result: HttpResponseResult =
Err(NetError::from(crate::api::error::ErrorKind::TimedOut));
let error = match result {
Ok(_) => return Err(std::io::Error::other("transport result was successful").into()),
Err(error) => error,
};
check(
error.kind() == crate::api::error::ErrorKind::TimedOut,
"wrong error kind",
)
}
}