use crate::types::{FailureClass, JobId};
use serde_json::{Map, Value};
use std::fmt;
use std::time::Duration;
include!(concat!(env!("OUT_DIR"), "/error_codes.rs"));
#[derive(Debug, Clone, PartialEq)]
pub struct TransportError {
pub code: TransportErrorCode,
pub status: Option<u16>,
pub message: String,
pub retry_after: Option<Duration>,
}
impl TransportError {
pub fn of_status(
message: impl Into<String>,
status: u16,
retry_after: Option<Duration>,
) -> TransportError {
TransportError {
code: TransportErrorCode::of_status(status),
status: Some(status),
message: message.into(),
retry_after,
}
}
pub fn without_response(
message: impl Into<String>,
code: TransportErrorCode,
) -> TransportError {
TransportError {
code,
status: None,
message: message.into(),
retry_after: None,
}
}
}
impl fmt::Display for TransportError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.message)
}
}
impl std::error::Error for TransportError {}
#[derive(Debug, Clone, PartialEq)]
pub struct BusRequestError {
pub code: BusRequestErrorCode,
pub message: String,
pub failure: Option<Map<String, Value>>,
}
impl BusRequestError {
pub fn new(code: BusRequestErrorCode, message: impl Into<String>) -> BusRequestError {
BusRequestError {
code,
message: message.into(),
failure: None,
}
}
}
impl fmt::Display for BusRequestError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.message)
}
}
impl std::error::Error for BusRequestError {}
#[derive(Debug, Clone, PartialEq)]
pub struct JobError {
pub code: JobErrorCode,
pub job_id: Option<JobId>,
pub message: String,
pub failure_class: Option<FailureClass>,
}
impl fmt::Display for JobError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.message)
}
}
impl std::error::Error for JobError {}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SessionError {
pub code: SessionErrorCode,
pub message: String,
pub kb_id: Option<String>,
}
impl SessionError {
pub fn new(code: SessionErrorCode, message: impl Into<String>, kb_id: &str) -> SessionError {
SessionError {
code,
message: message.into(),
kb_id: Some(kb_id.to_owned()),
}
}
}
impl fmt::Display for SessionError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.message)
}
}
impl std::error::Error for SessionError {}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SignInError {
pub code: SignInErrorCode,
pub message: String,
pub status: Option<u16>,
}
impl SignInError {
pub fn new(code: SignInErrorCode, message: impl Into<String>) -> SignInError {
SignInError {
code,
message: message.into(),
status: None,
}
}
pub fn answered(code: SignInErrorCode, message: impl Into<String>, status: u16) -> SignInError {
SignInError {
code,
message: message.into(),
status: Some(status),
}
}
}
impl fmt::Display for SignInError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.message)
}
}
impl std::error::Error for SignInError {}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct IdentityUnverifiable {
pub reason: IdentityUnverifiableReason,
pub detail: String,
}
impl fmt::Display for IdentityUnverifiable {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.detail)
}
}
impl std::error::Error for IdentityUnverifiable {}
impl fmt::Display for SpanRefusal {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.as_str())
}
}
impl std::error::Error for SpanRefusal {}
#[derive(Debug, Clone, PartialEq)]
pub enum SemiontError {
Bus(BusRequestError),
Transport(TransportError),
Job(JobError),
}
impl SemiontError {
pub fn code(&self) -> &'static str {
match self {
SemiontError::Bus(error) => error.code.as_str(),
SemiontError::Transport(error) => error.code.as_str(),
SemiontError::Job(error) => error.code.as_str(),
}
}
pub fn status(&self) -> Option<u16> {
match self {
SemiontError::Bus(_) | SemiontError::Job(_) => None,
SemiontError::Transport(error) => error.status,
}
}
}
impl fmt::Display for SemiontError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
SemiontError::Bus(error) => error.fmt(f),
SemiontError::Transport(error) => error.fmt(f),
SemiontError::Job(error) => error.fmt(f),
}
}
}
impl std::error::Error for SemiontError {}
impl From<JobError> for SemiontError {
fn from(error: JobError) -> SemiontError {
SemiontError::Job(error)
}
}
impl From<BusRequestError> for SemiontError {
fn from(error: BusRequestError) -> SemiontError {
SemiontError::Bus(error)
}
}
impl From<TransportError> for SemiontError {
fn from(error: TransportError) -> SemiontError {
SemiontError::Transport(error)
}
}
pub fn relayed_failure_code(error: &SemiontError) -> Option<crate::types::CommandErrorCode> {
match error {
SemiontError::Bus(error) => error.code.wire(),
SemiontError::Transport(_) | SemiontError::Job(_) => None,
}
}