//! Error module for `tor-dirserver`.

use thiserror::Error;

use tor_netdoc::parse2;

/// Indicates that an error variant is fatal.

///

/// A fatal error means that the application should abort execution and may

/// not retry again in the future.

///

/// This trait should only be implemented for error variants where some error

/// variants are fatal and others are not.  In other words: An error where all

/// variants are either fatal or non-fatal does not qualify for this trait.

// TODO DIRMIRROR: Move this to tor_error.

pub(crate) trait IsFatal: std::error::Error {

    /// Checks whether the current error is considered to be fatal.

    fn is_fatal(&self) -> bool;

}

/// An error while performing a request at a directory authority.

#[derive(Debug, Error)]

#[non_exhaustive]

pub(crate) enum AuthorityRequestError {

    /// TCP connection to the endpoint failed.

    #[error("tcp connection error: {0}")]

    TcpConnect(std::io::Error),

    /// [`tor_dirclient`] failed at performing the request.

    ///

    /// This usually indicates some failures in HTTP/1.0, such as the response

    /// not being valid HTTP/1.0; although Tor generally has some specialities

    /// here and there with regard to this, hence why we have dirclient in the

    /// first place.

    #[error("dirclient error: {0}")]

    Request(#[from] tor_dirclient::RequestFailedError),

    /// A response does not make semantic sense.

    ///

    /// This for example may include cases where we got more netdocs than we

    /// requested for.

    #[error("response error: {0}")]

    Response(&'static str),

    /// Invalid netdoc received from the authority.

    #[error("netdoc parse error: {0}")]

    Parse(#[from] parse2::ParseError),

    /// An internal error.

    #[error("internal error")]

    Bug(#[from] tor_error::Bug),

}

impl IsFatal for AuthorityRequestError {

    /// The [`AuthorityRequestError`] is considered to be fatal.

    ///

    /// Right now, the following variants are considered to be fatal:

    /// * [`AuthorityRequestError::Bug`]

}

/// An error while interacting with a database.

///

/// This error should be returned by all functions that interact with the

/// database in one way or another.

#[derive(Debug, Error)]

#[non_exhaustive]

pub(crate) enum DatabaseError {

    /// A low-level SQLite error has occurred, which can have a basically

    /// infinite amount of reasons, all of them outlined in the actual SQLite

    /// and [`rusqlite`] documentation.

    #[error("low-level rusqlite error: {0}")]

    LowLevel(#[from] rusqlite::Error),

    /// This is an application level error meaning that the database can be

    /// successfully accessed but its content implies it is of a schema version

    /// we do not support.

    ///

    /// Keep in mind that an unrecognized schema is not equal to no schema.

    /// In the latter case we actually initialize the database, whereas in the

    /// previous one, we fail early in order to not corrupt an existing database.

    /// Future versions of this crate should continue with this promise in order

    /// to ensure forward compatibility.

    #[error("incompatible schema version: {version}")]

    IncompatibleSchema {

        /// The incompatible schema version found in the database.

        version: String,

    },

    /// Interaction with our database pool, [`r2d2`], has failed.

    ///

    /// Unlike other database pools, this error is fairly straightforward and

    /// may only be obtained in the cases in which we try to obtain a connection

    /// handle from the pool.  Notably, it does not fail if, for example,

    /// the low-level [`rusqlite`] has a failure.

    #[error("pool error: {0}")]

    Pool(#[from] r2d2::Error),

    /// An internal error.

    #[error("Internal error")]

    Bug(#[from] tor_error::Bug),

}

/// An error related to an operation in the dirmirror FSM.

//

// TODO: Rename this to MirrorOperationError.

#[derive(Debug, Error)]

#[non_exhaustive]

pub(crate) enum OperationError {

    /// Request to a directory authority failed.

    #[error("authority request error: {0}")]

    AuthorityRequest(#[from] Box<AuthorityRequestError>),

    /// Access to the database failed for good.

    #[error("database error: {0}")]

    Database(#[from] DatabaseError),

    /// An internal error.

    #[error("Internal error")]

    Bug(#[from] tor_error::Bug),

}

impl From<AuthorityRequestError> for OperationError {

}

impl IsFatal for OperationError {

    /// The [`OperationError`] is considered to be fatal.

    ///

    /// Right now, the following variants are considered to be fatal:

    /// * [`OperationError::Database`]

    /// * [`OperationError::Bug`]

}