use std::error::Error as StdError;
use std::fmt;
use std::sync::Arc;
use std::time::Duration;
pub type ErrorCause = Arc<dyn StdError + Send + Sync + 'static>;
#[derive(Clone, Debug)]
#[non_exhaustive]
pub enum Error {
Api(Box<ApiError>),
Reference(ReferenceError),
ReferenceMismatch(ReferenceMismatchError),
InvalidArgument(String),
}
impl Error {
pub fn as_api(&self) -> Option<&ApiError> {
match self {
Self::Api(error) => Some(error.as_ref()),
_ => None,
}
}
pub(crate) fn invalid_argument(message: impl Into<String>) -> Self {
Self::InvalidArgument(message.into())
}
}
impl fmt::Display for Error {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Api(error) => error.fmt(formatter),
Self::Reference(error) => error.fmt(formatter),
Self::ReferenceMismatch(error) => error.fmt(formatter),
Self::InvalidArgument(message) => write!(formatter, "openhandle: {message}"),
}
}
}
impl StdError for Error {
fn source(&self) -> Option<&(dyn StdError + 'static)> {
match self {
Self::Api(error) => error.source(),
Self::Reference(error) => error.source(),
Self::ReferenceMismatch(_) | Self::InvalidArgument(_) => None,
}
}
}
impl From<ApiError> for Error {
fn from(error: ApiError) -> Self {
Self::Api(Box::new(error))
}
}
impl From<ReferenceError> for Error {
fn from(error: ReferenceError) -> Self {
Self::Reference(error)
}
}
impl From<ReferenceMismatchError> for Error {
fn from(error: ReferenceMismatchError) -> Self {
Self::ReferenceMismatch(error)
}
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct ApiError {
pub code: String,
pub message: String,
pub request_id: Option<String>,
pub retryable: bool,
pub retry_after: Option<Duration>,
pub status: Option<u16>,
pub details: Option<serde_json::Map<String, serde_json::Value>>,
pub cause: Option<ErrorCause>,
}
impl ApiError {
pub(crate) fn new(code: impl Into<String>, message: impl Into<String>) -> Self {
Self {
code: code.into(),
message: message.into(),
request_id: None,
retryable: false,
retry_after: None,
status: None,
details: None,
cause: None,
}
}
}
impl fmt::Display for ApiError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match &self.request_id {
Some(request_id) => write!(
formatter,
"openhandle: {}: {} (request {request_id})",
self.code, self.message
),
None => write!(formatter, "openhandle: {}: {}", self.code, self.message),
}
}
}
impl StdError for ApiError {
fn source(&self) -> Option<&(dyn StdError + 'static)> {
self.cause
.as_deref()
.map(|cause| cause as &(dyn StdError + 'static))
}
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct ReferenceError {
pub message: String,
pub cause: Option<ErrorCause>,
}
impl ReferenceError {
pub(crate) fn new(message: impl Into<String>) -> Self {
Self {
message: message.into(),
cause: None,
}
}
}
impl fmt::Display for ReferenceError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(formatter, "openhandle: {}", self.message)
}
}
impl StdError for ReferenceError {
fn source(&self) -> Option<&(dyn StdError + 'static)> {
self.cause
.as_deref()
.map(|cause| cause as &(dyn StdError + 'static))
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct ReferenceMismatchError {
pub expected_platform: String,
pub expected_resource: String,
pub actual_platform: String,
pub actual_resource: String,
}
impl fmt::Display for ReferenceMismatchError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(
formatter,
"openhandle: expected a {} {} URL, received a {} {} URL",
self.expected_platform,
self.expected_resource,
self.actual_platform,
self.actual_resource
)
}
}
impl StdError for ReferenceMismatchError {}