use thiserror::Error;
use crate::{
applications::error::ApplicationsError, images::error::ImagesError,
secrets::error::SecretsError,
};
#[derive(Debug, Error)]
pub enum SdkError {
#[error(transparent)]
Applications(#[from] ApplicationsError),
#[error("Authentication failed: {0}")]
Authentication(String),
#[error("Authorization failed: {0}")]
Authorization(String),
#[error(transparent)]
Http(#[from] reqwest::Error),
#[error(transparent)]
Middleware(#[from] reqwest_middleware::Error),
#[error(transparent)]
Images(#[from] ImagesError),
#[error("Invalid header value: {0}")]
InvalidHeaderValue(String),
#[error("Client error: {0}")]
ClientError(String),
#[error(transparent)]
Io(#[from] std::io::Error),
#[error(transparent)]
Json(#[from] serde_json::Error),
#[error(transparent)]
JsonWithError(#[from] serde_path_to_error::Error<serde_json::Error>),
#[error(transparent)]
Secrets(#[from] SecretsError),
#[error("Server error: {status} - {message}")]
ServerError {
status: reqwest::StatusCode,
message: String,
},
#[error("EventSource error: {0}")]
EventSourceError(String),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TransportFailure {
Connect,
Timeout,
}
impl SdkError {
pub fn as_reqwest(&self) -> Option<&reqwest::Error> {
match self {
Self::Http(error) => Some(error),
Self::Middleware(reqwest_middleware::Error::Reqwest(error)) => Some(error),
_ => None,
}
}
pub fn transport_failure(&self) -> Option<TransportFailure> {
let error = self.as_reqwest()?;
if error.is_timeout() {
Some(TransportFailure::Timeout)
} else if error.is_connect() {
Some(TransportFailure::Connect)
} else {
None
}
}
pub fn detail(&self) -> String {
format_error_chain(self)
}
}
pub fn format_error_chain(error: &dyn std::error::Error) -> String {
let mut message = error.to_string();
let mut source = error.source();
while let Some(cause) = source {
let cause_message = cause.to_string();
if !cause_message.is_empty() && !message.ends_with(&cause_message) {
message.push_str(": ");
message.push_str(&cause_message);
}
source = cause.source();
}
message
}
#[cfg(test)]
mod transport_failure_tests {
use super::{SdkError, TransportFailure};
async fn middleware_connect_error() -> SdkError {
let client = reqwest_middleware::ClientBuilder::new(
crate::http_transport::https_builder().build().unwrap(),
)
.build();
SdkError::from(client.get("http://127.0.0.1:1/x").send().await.unwrap_err())
}
#[tokio::test]
async fn middleware_connect_failure_is_classified_as_connect() {
let error = middleware_connect_error().await;
assert_eq!(
error.transport_failure(),
Some(TransportFailure::Connect),
"a connect failure through middleware must classify as Connect, not fall through \
to the untyped arm"
);
}
#[tokio::test]
async fn middleware_connect_failure_message_alone_names_no_cause() {
let error = middleware_connect_error().await;
let rendered = error.to_string().to_lowercase();
assert!(
!rendered.contains("connect") && !rendered.contains("timeout"),
"reqwest's Display is expected to hide the cause; got {rendered:?}"
);
}
#[tokio::test]
async fn middleware_timeout_is_classified_as_timeout() {
let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("listener");
let address = listener.local_addr().expect("address");
std::thread::spawn(move || {
let mut held = Vec::new();
while let Ok((stream, _)) = listener.accept() {
held.push(stream);
}
});
let client = reqwest_middleware::ClientBuilder::new(
crate::http_transport::https_builder()
.timeout(std::time::Duration::from_millis(200))
.build()
.unwrap(),
)
.build();
let error = SdkError::from(
client
.get(format!("http://{address}/x"))
.send()
.await
.unwrap_err(),
);
assert_eq!(error.transport_failure(), Some(TransportFailure::Timeout));
}
#[tokio::test]
async fn detail_surfaces_the_underlying_cause() {
let error = middleware_connect_error().await;
let detail = error.detail().to_lowercase();
assert!(
detail.contains("tcp connect error"),
"detail() must expose the source chain; got {detail:?}"
);
}
}