Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

2.3 KB
Raw Blame
use thiserror::Error;

use crate::db::models::EntityType;

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

#[derive(Error, Debug)]
pub enum Error {
    #[error("invalid encryption key length: expected {expected}, got {actual}")]
    InvalidKeyLength { expected: usize, actual: usize },

    #[error("invalid blob length: expected at least {minimum} bytes, got {actual}")]
    InvalidBlobLength { minimum: usize, actual: usize },

    #[error("invalid encrypted field format")]
    InvalidEncryptedField,

    #[error("unsupported value type: {0}")]
    UnsupportedValueType(String),

    #[error("row error: {0}")]
    Row(String),

    #[error("invalid sender: {0}")]
    InvalidSender(String),

    #[error("{entity:?} not found: {id}")]
    NotFound { entity: EntityType, id: uuid::Uuid },

    #[error(transparent)]
    Crypto(#[from] ente_core::crypto::Error),

    #[error(transparent)]
    Base64Decode(#[from] ente_core::b64::DecodeError),

    #[error(transparent)]
    SerdeJson(#[from] serde_json::Error),

    #[error(transparent)]
    Uuid(#[from] uuid::Error),

    #[error(transparent)]
    Utf8(#[from] std::string::FromUtf8Error),

    #[error(transparent)]
    Io(#[from] std::io::Error),

    #[error("database is readonly")]
    ReadonlyDatabase,

    #[cfg(feature = "sqlite")]
    #[error(transparent)]
    Sqlite(rusqlite::Error),

    #[error("unsupported operation: {0}")]
    UnsupportedOperation(String),

    #[error("migration error: {0}")]
    Migration(String),
}

impl From<ente_ensu_crypto::Error> for Error {
    fn from(error: ente_ensu_crypto::Error) -> Self {
        use ente_ensu_crypto::Error as E;

        match error {
            E::InvalidBlobLength { minimum, actual } => Self::InvalidBlobLength { minimum, actual },
            E::InvalidEncryptedField => Self::InvalidEncryptedField,
            E::Crypto(error) => Self::Crypto(error),
            E::Base64Decode(error) => Self::Base64Decode(error),
            E::Utf8(error) => Self::Utf8(error),
        }
    }
}

#[cfg(feature = "sqlite")]
impl From<rusqlite::Error> for Error {
    fn from(err: rusqlite::Error) -> Self {
        match &err {
            rusqlite::Error::SqliteFailure(failure, _)
                if failure.code == rusqlite::ErrorCode::ReadOnly =>
            {
                Error::ReadonlyDatabase
            }
            _ => Error::Sqlite(err),
        }
    }
}