modrinth/apps/labrinth/src/file_hosting/mod.rs

use std::error::Error;
use std::str::FromStr;

use async_trait::async_trait;
use thiserror::Error;

mod mock;
mod s3_host;

use bytes::Bytes;
pub use mock::MockHost;
pub use s3_host::{S3BucketConfig, S3Host};

#[derive(Error, Debug)]
pub enum FileHostingError {
    #[error("S3 error when {0}: {1}")]
    S3Error(&'static str, #[source] Box<dyn Error + Send + Sync>),
    #[error("File system error in file hosting: {0}")]
    FileSystemError(#[from] std::io::Error),
    #[error("Invalid Filename")]
    InvalidFilename,
}

#[derive(Debug, Clone)]
pub struct UploadFileData {
    pub file_name: String,
    pub file_publicity: FileHostPublicity,
    pub content_length: u32,
    pub content_sha512: String,
    pub content_sha1: String,
    pub content_md5: Option<String>,
    pub content_type: String,
    pub upload_timestamp: u64,
}

#[derive(Debug, Clone)]
pub struct DeleteFileData {
    pub file_name: String,
}

#[derive(Debug, Copy, Clone)]
pub enum FileHostPublicity {
    Public,
    Private,
}

#[async_trait]
pub trait FileHost: Send + Sync {
    /// Uploads a file at the exact storage key provided.
    ///
    /// Callers must URL-decode keys derived from public URLs before passing
    /// them here, and URL-encode this key before exposing it in a public URL.
    async fn upload_file(
        &self,
        content_type: &str,
        file_name: &str,
        file_publicity: FileHostPublicity,
        file_bytes: Bytes,
    ) -> Result<UploadFileData, FileHostingError>;

    /// Returns a private URL for the exact storage key provided.
    ///
    /// Callers must URL-decode keys derived from public URLs before passing
    /// them here.
    async fn get_url_for_private_file(
        &self,
        file_name: &str,
        expiry_secs: u32,
    ) -> Result<String, FileHostingError>;

    /// Deletes the file at the exact storage key provided.
    ///
    /// Callers must URL-decode keys derived from public URLs before passing
    /// them here.
    async fn delete_file(
        &self,
        file_name: &str,
        file_publicity: FileHostPublicity,
    ) -> Result<DeleteFileData, FileHostingError>;

    /// Reads the file at the exact storage key provided.
    ///
    /// Callers must URL-decode keys derived from public URLs before passing
    /// them here.
    async fn read_file(
        &self,
        file_name: &str,
        file_publicity: FileHostPublicity,
    ) -> Result<Bytes, FileHostingError>;
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum FileHostKind {
    S3,
    Local,
}

#[derive(Debug, Error)]
#[error("invalid file host kind")]
pub struct InvalidFileHostKind;

impl FromStr for FileHostKind {
    type Err = InvalidFileHostKind;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Ok(match s {
            "s3" => Self::S3,
            "local" => Self::Local,
            _ => return Err(InvalidFileHostKind),
        })
    }
}