use std::fmt;
use std::time::Duration;
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub enum Error {
Config(String),
Auth(String),
RateLimited {
message: String,
retry_after: Option<Duration>,
},
Api { status: u16, message: String },
Network(String),
Stream(String),
Decode(String),
Cancelled,
}
impl Error {
pub fn retryable(&self) -> bool {
match self {
Error::RateLimited { .. } | Error::Network(_) | Error::Stream(_) => true,
Error::Api { status, .. } => matches!(status, 408 | 409 | 500 | 502 | 503 | 504),
_ => false,
}
}
pub fn is_auth(&self) -> bool {
matches!(self, Error::Auth(_))
}
pub fn retry_after(&self) -> Option<Duration> {
match self {
Error::RateLimited { retry_after, .. } => *retry_after,
_ => None,
}
}
pub fn status(&self) -> Option<u16> {
match self {
Error::Api { status, .. } => Some(*status),
Error::RateLimited { .. } => Some(429),
_ => None,
}
}
}
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Error::Config(message) => write!(f, "{message}"),
Error::Auth(message) => write!(f, "{message}"),
Error::RateLimited {
message,
retry_after,
} => match retry_after {
Some(wait) => write!(f, "rate limited, retry in {}s: {message}", wait.as_secs()),
None => write!(f, "rate limited: {message}"),
},
Error::Api { status, message } => write!(f, "HTTP {status}: {message}"),
Error::Network(message) => write!(f, "network: {message}"),
Error::Stream(message) => write!(f, "stream: {message}"),
Error::Decode(message) => write!(f, "unexpected response: {message}"),
Error::Cancelled => write!(f, "cancelled"),
}
}
}
impl std::error::Error for Error {}
impl From<Error> for String {
fn from(error: Error) -> String {
error.to_string()
}
}
pub type Result<T> = std::result::Result<T, Error>;
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn only_transient_failures_are_worth_repeating() {
assert!(Error::RateLimited {
message: "slow down".into(),
retry_after: Some(Duration::from_secs(3))
}
.retryable());
assert!(Error::Api {
status: 503,
message: "overloaded".into()
}
.retryable());
assert!(Error::Network("connection reset".into()).retryable());
assert!(!Error::Auth("bad key".into()).retryable());
assert!(!Error::Api {
status: 400,
message: "bad request".into()
}
.retryable());
assert!(!Error::Cancelled.retryable());
}
#[test]
fn a_rate_limit_carries_the_wait_the_server_asked_for() {
let error = Error::RateLimited {
message: "quota".into(),
retry_after: Some(Duration::from_secs(12)),
};
assert_eq!(error.retry_after(), Some(Duration::from_secs(12)));
assert_eq!(error.status(), Some(429));
assert!(error.to_string().contains("retry in 12s"));
}
#[test]
fn string_callers_keep_working() {
fn legacy() -> std::result::Result<(), String> {
Err(Error::Auth("expired".into()))?;
Ok(())
}
assert_eq!(legacy().unwrap_err(), "expired");
}
}