bffh/src/error.rs

use std::io;
use std::fmt;
use toml;
use serde_dhall;

use rsasl::SaslError;

// SpawnError is a somewhat ambigous name, `use as` to make it futures::SpawnError instead.
use futures::task as futures_task;

use crate::network;

#[derive(Debug)]
pub enum Error {
    BadConfiguration,
    TomlDe(toml::de::Error),
    TomlSer(toml::ser::Error),
    Dhall(serde_dhall::Error),
    SASL(SaslError),
    IO(io::Error),
    Boxed(Box<dyn std::error::Error>),
    Capnp(capnp::Error),
    LMDB(lmdb::Error),
    FlexbuffersDe(flexbuffers::DeserializationError),
    FlexbuffersSer(flexbuffers::SerializationError),
    FuturesSpawn(futures_task::SpawnError),
    MQTT(rumqttc::ClientError),
    MQTTConnectionError(rumqttc::ConnectionError),
    BadVersion((u32,u32)),
    Argon2(argon2::Error),
    EventNetwork(network::Error),
    RustTls(rustls::TLSError),
    ParseUrl(url::ParseError),
    Denied,
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Error::TomlDe(e) => {
                write!(f, "TOML Decoding error: {}", e)
            },
            Error::TomlSer(e) => {
                write!(f, "TOML Serialization error: {}", e)
            },
            Error::Dhall(e) => {
                write!(f, "Dhall coding error: {}", e)
            },
            Error::SASL(e) => {
                write!(f, "SASL Error: {}", e)
            },
            Error::IO(e) => {
                write!(f, "IO Error: {}", e)
            },
            Error::Boxed(e) => {
                write!(f, "{}", e)
            },
            Error::Capnp(e) => {
                write!(f, "Cap'n Proto Error: {}", e)
            },
            Error::LMDB(e) => {
                write!(f, "LMDB Error: {}", e)
            },
            Error::FlexbuffersDe(e) => {
                write!(f, "Flexbuffers decoding error: {}", e)
            },
            Error::FlexbuffersSer(e) => {
                write!(f, "Flexbuffers encoding error: {}", e)
            },
            Error::FuturesSpawn(e) => {
                write!(f, "Future could not be spawned: {}", e)
            },
            Error::MQTT(e) => {
                write!(f, "MQTT client encountered an error: {:?}", e)
            },
            Error::Argon2(e) => {
                write!(f, "Argon2 en/decoding failure: {}", e)
            }
            Error::BadVersion((major,minor)) => {
                write!(f, "Peer uses API version {}.{} which is incompatible!", major, minor)
            }
            Error::Denied => {
                write!(f, "You do not have the permission required to do that.")
            }
            Error::EventNetwork(e) => {
                e.fmt(f)
            }
            Error::RustTls(e) => {
                write!(f, "TLS Error: {}", e)
            }
            Error::ParseUrl(e) => write!(f, "Failed to parse URL: {}", e),
            Error::BadConfiguration => write!(f, "Bad configuration provided"),
            Error::MQTTConnectionError(e) => write!(f, "MQTT connection error: {:?}", e),
        }
    }
}

impl From<SaslError> for Error {
    fn from(e: SaslError) -> Error {
        Error::SASL(e)
    }
}

impl From<io::Error> for Error {
    fn from(e: io::Error) -> Error {
        Error::IO(e)
    }
}

impl From<toml::de::Error> for Error {
    fn from(e: toml::de::Error) -> Error {
        Error::TomlDe(e)
    }
}

impl From<toml::ser::Error> for Error {
    fn from(e: toml::ser::Error) -> Error {
        Error::TomlSer(e)
    }
}

impl From<serde_dhall::Error> for Error {
    fn from(e: serde_dhall::Error) -> Error {
        Error::Dhall(e)
    }
}

impl From<Box<dyn std::error::Error>> for Error {
    fn from(e: Box<dyn std::error::Error>) -> Error {
        Error::Boxed(e)
    }
}

impl From<capnp::Error> for Error {
    fn from(e: capnp::Error) -> Error {
        Error::Capnp(e)
    }
}

impl From<lmdb::Error> for Error {
    fn from(e: lmdb::Error) -> Error {
        Error::LMDB(e)
    }
}

impl From<flexbuffers::DeserializationError> for Error {
    fn from(e: flexbuffers::DeserializationError) -> Error {
        Error::FlexbuffersDe(e)
    }
}

impl From<flexbuffers::SerializationError> for Error {
    fn from(e: flexbuffers::SerializationError) -> Error {
        Error::FlexbuffersSer(e)
    }
}

impl From<futures_task::SpawnError> for Error {
    fn from(e: futures_task::SpawnError) -> Error {
        Error::FuturesSpawn(e)
    }
}

impl From<rumqttc::ClientError> for Error {
    fn from(e: rumqttc::ClientError) -> Error {
        Error::MQTT(e)
    }
}

impl From<rumqttc::ConnectionError> for Error {
    fn from(e: rumqttc::ConnectionError) -> Error {
        Error::MQTTConnectionError(e)
    }
}

impl From<network::Error> for Error {
    fn from(e: network::Error) -> Error {
        Error::EventNetwork(e)
    }
}

impl From<url::ParseError> for Error {
    fn from(e: url::ParseError) -> Error {
        Error::ParseUrl(e)
    }
}

impl From<argon2::Error> for Error {
    fn from(e: argon2::Error) -> Error {
        Error::Argon2(e)
    }
}

impl From<rustls::TLSError> for Error {
    fn from(e: rustls::TLSError) -> Error {
        Error::RustTls(e)
    }
}

pub(crate) type Result<T> = std::result::Result<T, Error>;