280 lines
9.1 KiB
Rust
280 lines
9.1 KiB
Rust
#![warn(missing_docs)]
|
|
|
|
//! Error handling for various aspects of the PeachCloud system, including the network, OLED, stats and dyndns JSON-RPC clients, as well as the configuration manager, sbot client and password utilities.
|
|
|
|
use golgi::GolgiError;
|
|
use std::{io, str, string};
|
|
|
|
/// This type represents all possible errors that can occur when interacting with the PeachCloud library.
|
|
#[derive(Debug)]
|
|
pub enum PeachError {
|
|
/// Represents looking up a Config value with a non-existent key
|
|
InvalidKey {
|
|
/// the key value which was invalid
|
|
key: String,
|
|
},
|
|
|
|
/// Represents a failure to determine the path of the user's home directory.
|
|
HomeDir,
|
|
|
|
/// Represents all other cases of `std::io::Error`.
|
|
Io(io::Error),
|
|
|
|
/// Represents a JSON-RPC core error returned from a JSON-RPC client.
|
|
JsonRpcClientCore(jsonrpc_client_core::Error),
|
|
|
|
/// Represents a JSON-RPC core error returned from a JSON-RPC server.
|
|
JsonRpcCore(jsonrpc_core::Error),
|
|
|
|
/// Represents a JSON-RPC HTTP error returned from a JSON-RPC client.
|
|
JsonRpcHttp(jsonrpc_client_http::Error),
|
|
|
|
/// Represents a failure to update the nameserver.
|
|
NsUpdate {
|
|
/// A message describing the context of the attempted nameserver update.
|
|
msg: String,
|
|
},
|
|
|
|
/// Represents a failure to parse a string slice to a boolean value.
|
|
ParseBool(str::ParseBoolError),
|
|
|
|
/// Represents a failure to parse a `DateTime`. Includes the error source and the file path
|
|
/// used in the parse attempt.
|
|
ParseDateTime {
|
|
/// The underlying source of the error.
|
|
source: chrono::ParseError,
|
|
/// The file path for the parse attempt.
|
|
path: String,
|
|
},
|
|
|
|
/// Represents the submission of an incorrect admin password.
|
|
PasswordIncorrect,
|
|
|
|
/// Represents the submission of two passwords which do not match.
|
|
PasswordMismatch,
|
|
|
|
/// Represents an unset admin password (empty password hash value) in the config file.
|
|
PasswordNotSet,
|
|
|
|
/// Represents a failure to read from input. Includes the error source and the file path used
|
|
/// in the read attempt.
|
|
Read {
|
|
/// The underlying source of the error.
|
|
source: io::Error,
|
|
/// The file path for the read attempt.
|
|
path: String,
|
|
},
|
|
|
|
/// Represents a failure to parse or compile a regular expression.
|
|
Regex(regex::Error),
|
|
|
|
/// Represents a failure to successfully execute an sbot command (via golgi).
|
|
Sbot(String),
|
|
|
|
/// Represents a failure to serialize or deserialize JSON.
|
|
SerdeJson(serde_json::error::Error),
|
|
|
|
/// Represents a failure to deserialize TOML.
|
|
TomlDeser(toml::de::Error),
|
|
|
|
/// Represents a failure to serialize TOML.
|
|
TomlSer(toml::ser::Error),
|
|
|
|
/// Represents a failure to serialize or deserialize YAML.
|
|
SerdeYaml(serde_yaml::Error),
|
|
|
|
/// Represents a failure to find the given SSB ID in the config file.
|
|
SsbAdminIdNotFound {
|
|
/// An SSB ID (public key).
|
|
id: String,
|
|
},
|
|
|
|
/// Represents a failure to interpret a sequence of u8 as a string slice.
|
|
Utf8ToStr(str::Utf8Error),
|
|
|
|
/// Represents a failure to interpret a sequence of u8 as a String.
|
|
Utf8ToString(string::FromUtf8Error),
|
|
|
|
/// Represents a failure to write to output. Includes the error source and the file path used
|
|
/// in the write attempt.
|
|
Write {
|
|
/// The underlying source of the error.
|
|
source: io::Error,
|
|
/// The file path for the write attempt.
|
|
path: String,
|
|
},
|
|
|
|
/// Represents a Golgi error
|
|
Golgi(GolgiError),
|
|
|
|
/// Represents a generic system error, whose details are specified in the string message
|
|
System(String),
|
|
|
|
}
|
|
|
|
impl std::error::Error for PeachError {
|
|
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
|
|
match *self {
|
|
PeachError::HomeDir => None,
|
|
PeachError::InvalidKey { .. } => None,
|
|
PeachError::Io(_) => None,
|
|
PeachError::JsonRpcClientCore(_) => None,
|
|
PeachError::JsonRpcCore(_) => None,
|
|
PeachError::JsonRpcHttp(_) => None,
|
|
PeachError::NsUpdate { .. } => None,
|
|
PeachError::ParseBool(_) => None,
|
|
PeachError::ParseDateTime { ref source, .. } => Some(source),
|
|
PeachError::PasswordIncorrect => None,
|
|
PeachError::PasswordMismatch => None,
|
|
PeachError::PasswordNotSet => None,
|
|
PeachError::Read { ref source, .. } => Some(source),
|
|
PeachError::Regex(_) => None,
|
|
PeachError::Sbot(_) => None,
|
|
PeachError::SerdeJson(_) => None,
|
|
PeachError::SerdeYaml(_) => None,
|
|
PeachError::SsbAdminIdNotFound { .. } => None,
|
|
PeachError::TomlDeser(_) => None,
|
|
PeachError::TomlSer(_) => None,
|
|
PeachError::Utf8ToStr(_) => None,
|
|
PeachError::Utf8ToString(_) => None,
|
|
PeachError::Write { ref source, .. } => Some(source),
|
|
PeachError::Golgi(_) => None,
|
|
PeachError::System(_) => None,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl std::fmt::Display for PeachError {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
|
|
match *self {
|
|
PeachError::InvalidKey { ref key } => {
|
|
write!(f, "Invalid key in config lookup for key: {}", key)
|
|
}
|
|
PeachError::HomeDir => {
|
|
write!(
|
|
f,
|
|
"Unable to determine the path of the user's home directory"
|
|
)
|
|
}
|
|
PeachError::Io(ref err) => err.fmt(f),
|
|
PeachError::JsonRpcClientCore(ref err) => err.fmt(f),
|
|
PeachError::JsonRpcCore(ref err) => {
|
|
write!(f, "{:?}", err)
|
|
}
|
|
PeachError::JsonRpcHttp(ref err) => err.fmt(f),
|
|
PeachError::NsUpdate { ref msg } => {
|
|
write!(f, "Nameserver error: {}", msg)
|
|
}
|
|
PeachError::ParseBool(ref err) => err.fmt(f),
|
|
PeachError::ParseDateTime { ref path, .. } => {
|
|
write!(f, "Date/time parse error: {}", path)
|
|
}
|
|
PeachError::PasswordIncorrect => {
|
|
write!(f, "password is incorrect")
|
|
}
|
|
PeachError::PasswordMismatch => {
|
|
write!(f, "passwords do not match")
|
|
}
|
|
PeachError::PasswordNotSet => {
|
|
write!(f, "hash value in YAML configuration file is empty")
|
|
}
|
|
PeachError::Read { ref path, .. } => {
|
|
write!(f, "Read error: {}", path)
|
|
}
|
|
PeachError::Regex(ref err) => err.fmt(f),
|
|
PeachError::Sbot(ref msg) => {
|
|
write!(f, "Sbot error: {}", msg)
|
|
}
|
|
PeachError::SerdeJson(ref err) => err.fmt(f),
|
|
PeachError::SerdeYaml(ref err) => err.fmt(f),
|
|
PeachError::SsbAdminIdNotFound { ref id } => {
|
|
write!(f, "Config error: SSB admin ID `{}` not found", id)
|
|
}
|
|
PeachError::TomlDeser(ref err) => err.fmt(f),
|
|
PeachError::TomlSer(ref err) => err.fmt(f),
|
|
PeachError::Utf8ToStr(ref err) => err.fmt(f),
|
|
PeachError::Utf8ToString(ref err) => err.fmt(f),
|
|
PeachError::Write { ref path, .. } => {
|
|
write!(f, "Write error: {}", path)
|
|
}
|
|
PeachError::Golgi(ref err) => err.fmt(f),
|
|
PeachError::System(ref msg) => {
|
|
write!(f, "system error: {}", msg)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<std::io::Error> for PeachError {
|
|
fn from(err: std::io::Error) -> PeachError {
|
|
PeachError::Io(err)
|
|
}
|
|
}
|
|
|
|
impl From<jsonrpc_client_core::Error> for PeachError {
|
|
fn from(err: jsonrpc_client_core::Error) -> PeachError {
|
|
PeachError::JsonRpcClientCore(err)
|
|
}
|
|
}
|
|
|
|
impl From<jsonrpc_client_http::Error> for PeachError {
|
|
fn from(err: jsonrpc_client_http::Error) -> PeachError {
|
|
PeachError::JsonRpcHttp(err)
|
|
}
|
|
}
|
|
|
|
impl From<str::ParseBoolError> for PeachError {
|
|
fn from(err: str::ParseBoolError) -> PeachError {
|
|
PeachError::ParseBool(err)
|
|
}
|
|
}
|
|
|
|
impl From<regex::Error> for PeachError {
|
|
fn from(err: regex::Error) -> PeachError {
|
|
PeachError::Regex(err)
|
|
}
|
|
}
|
|
|
|
impl From<serde_json::error::Error> for PeachError {
|
|
fn from(err: serde_json::error::Error) -> PeachError {
|
|
PeachError::SerdeJson(err)
|
|
}
|
|
}
|
|
|
|
impl From<serde_yaml::Error> for PeachError {
|
|
fn from(err: serde_yaml::Error) -> PeachError {
|
|
PeachError::SerdeYaml(err)
|
|
}
|
|
}
|
|
|
|
impl From<toml::de::Error> for PeachError {
|
|
fn from(err: toml::de::Error) -> PeachError {
|
|
PeachError::TomlDeser(err)
|
|
}
|
|
}
|
|
|
|
impl From<toml::ser::Error> for PeachError {
|
|
fn from(err: toml::ser::Error) -> PeachError {
|
|
PeachError::TomlSer(err)
|
|
}
|
|
}
|
|
|
|
impl From<str::Utf8Error> for PeachError {
|
|
fn from(err: str::Utf8Error) -> PeachError {
|
|
PeachError::Utf8ToStr(err)
|
|
}
|
|
}
|
|
|
|
impl From<string::FromUtf8Error> for PeachError {
|
|
fn from(err: string::FromUtf8Error) -> PeachError {
|
|
PeachError::Utf8ToString(err)
|
|
}
|
|
}
|
|
|
|
impl From<GolgiError> for PeachError {
|
|
fn from(err: GolgiError) -> PeachError {
|
|
PeachError::Golgi(err)
|
|
}
|
|
}
|
|
|