Store config in FileStore

Author: metame

server/src/config.rs

@@ -1,6 +1,7 @@
 //! Parse CLI options, setup on boot, read .env values
 
 use crate::errors::AtomicServerResult;
+use crate::files::FileStore;
 use clap::Parser;
 use dotenv::dotenv;
 use std::net::IpAddr;
@@ -206,6 +207,10 @@ pub struct Config {
     pub uploads_path: PathBuf,
     /// Path to where the search index for tantivy full text search is located
     pub search_index_path: PathBuf,
+    /// stores config values and the active FileStore type, e.g. FS or S3
+    pub file_store: FileStore,
+    /// stores config values for FS filestore regardless of active file store as fallback
+    pub fs_file_store: FileStore,
     /// If true, the initialization scripts will be ran (create first Drive, Agent, indexing, etc)
     pub initialize: bool,
 }
@@ -265,6 +270,10 @@ pub fn build_config(opts: Opts) -> AtomicServerResult<Config> {
 
     let initialize = !std::path::Path::exists(&store_path) || opts.initialize;
 
+    // Initialize FileStore config
+    let fs_file_store = FileStore::init_fs_from_config(&opts);
+    let file_store = FileStore::init_from_config(&opts, fs_file_store.clone());
+
     if opts.https & opts.email.is_none() {
         return Err(
             "The `--email` flag (or ATOMIC_EMAIL env) is required for getting an HTTPS certificate from letsencrypt.org."
@@ -296,5 +305,7 @@ pub fn build_config(opts: Opts) -> AtomicServerResult<Config> {
         store_path,
         search_index_path,
         uploads_path,
+        file_store,
+        fs_file_store,
     })
 }

server/src/files.rs

@@ -3,37 +3,59 @@ use std::{fmt, path::PathBuf, time::Duration};
 use opendal::{services::S3, Operator};
 use tokio::fs::File;
 
-use crate::{appstate::AppState, config::Config, errors::AtomicServerResult};
+use crate::{config::{Config, Opts}, errors::AtomicServerResult};
 
+#[derive(Clone, Debug)]
 pub enum FileStore {
-    S3,
-    FS,
+    S3(S3Config),
+    FS(FSConfig),
 }
 
+#[derive(Clone, Debug)]
+pub struct S3Config {
+    bucket: String,
+    path: String,
+    endpoint: Option<String>,
+    region: Option<String>,
+}
+
+#[derive(Clone, Debug)]
+pub struct FSConfig {}
+
 impl FileStore {
     const S3_PREFIX: &'static str = "s3:";
     const FS_PREFIX: &'static str = "fs:";
 
-    pub fn get_config_file_store(config: &Config) -> FileStore {
-        if config.opts.s3_bucket.is_some() {
-            FileStore::S3
+    pub fn init_fs_from_config(_opts: &Opts) -> FileStore {
+        FileStore::FS(FSConfig {})
+    }
+
+    pub fn init_from_config(opts: &Opts, fs_file_store: FileStore) -> FileStore {
+        if opts.s3_bucket.is_some() {
+            let config = S3Config {
+                bucket: opts.s3_bucket.clone().unwrap(),
+                endpoint: opts.s3_endpoint.clone(),
+                region: opts.s3_region.clone(),
+                path: opts.s3_path.clone().unwrap_or("uploads".to_string()),
+            };
+            FileStore::S3(config)
         } else {
-            FileStore::FS
+            fs_file_store
         }
     }
 
-    pub fn get_subject_file_store(subject: &str) -> FileStore {
+    pub fn get_subject_file_store<'a>(config: &'a Config, subject: &str) -> &'a FileStore {
         if subject.contains(Self::S3_PREFIX) {
-            FileStore::S3
+            &config.file_store
         } else {
-            FileStore::FS
+            &config.fs_file_store
         }
     }
 
     pub fn prefix(&self) -> &str {
         match self {
-            Self::S3 => Self::S3_PREFIX,
-            Self::FS => Self::FS_PREFIX,
+            Self::S3(_) => Self::S3_PREFIX,
+            Self::FS(_) => Self::FS_PREFIX,
         }
     }
 
@@ -49,92 +71,52 @@ impl fmt::Display for FileStore {
 }
 
 pub async fn s3_upload_object(
-    appstate: &AppState,
+    file_store: &FileStore,
     file_id: &str,
     file_path: &PathBuf,
 ) -> AtomicServerResult<()> {
     let mut builder = S3::default();
-    let bucket = appstate
-        .config
-        .opts
-        .s3_bucket
-        .as_ref()
-        .ok_or("uploading to s3 but no s3 bucket configured")?;
-    builder.bucket(bucket);
-    appstate
-        .config
-        .opts
-        .s3_region
-        .as_ref()
-        .map(|r| builder.region(&r));
-    appstate
-        .config
-        .opts
-        .s3_endpoint
-        .as_ref()
-        .map(|e| builder.endpoint(&e));
-
-    let default_path = &"uploads".to_string();
-    let path = appstate
-        .config
-        .opts
-        .s3_path
-        .as_ref()
-        .unwrap_or(default_path);
+
+    if let FileStore::S3(config) = file_store {
+        builder.bucket(&config.bucket);
+        builder.root(&config.path);
+        config.region.as_ref().map(|r| builder.region(&r));
+        config.endpoint.as_ref().map(|e| builder.endpoint(&e));
+    } else {
+        return Err("Uploading to S3 but no S3 config provided".into());
+    }
 
     let op: Operator = Operator::new(builder)?.finish();
 
     let mut tmp_file = File::open(file_path).await?;
     let length = tmp_file.metadata().await?.len();
 
-    let s3_path = format!("{}/{}", path, &file_id);
-    let mut w = op.writer_with(&s3_path).content_length(length).await?;
+    let mut w = op.writer_with(&file_id).content_length(length).await?;
     tokio::io::copy(&mut tmp_file, &mut w).await?;
     w.close().await?;
     Ok(())
 }
 
 pub async fn get_s3_signed_url(
-    appstate: &AppState,
+    file_store: &FileStore,
     duration: Duration,
     file_id: &str,
 ) -> AtomicServerResult<String> {
     let mut builder = S3::default();
 
-    let bucket = appstate
-        .config
-        .opts
-        .s3_bucket
-        .as_ref()
-        .ok_or("s3 file found but no s3 bucket")?;
-    builder.bucket(bucket);
-
-    appstate
-        .config
-        .opts
-        .s3_region
-        .as_ref()
-        .map(|r| builder.region(&r));
-
-    appstate
-        .config
-        .opts
-        .s3_endpoint
-        .as_ref()
-        .map(|e| builder.endpoint(&e));
-
-    let default_path = &"uploads".to_string();
-    let path = appstate
-        .config
-        .opts
-        .s3_path
-        .as_ref()
-        .unwrap_or(default_path);
+    if let FileStore::S3(config) = file_store {
+        builder.bucket(&config.bucket);
+        builder.root(&config.path);
+        config.region.as_ref().map(|r| builder.region(&r));
+        config.endpoint.as_ref().map(|e| builder.endpoint(&e));
+    } else {
+        return Err("Downloading from S3 but no S3 config provided".into());
+    }
 
     let op: Operator = Operator::new(builder)?.finish();
 
     let uri = op
-        .presign_read(&format!("{}/{}", &path, file_id), duration)
+        .presign_read(file_id, duration)
         .await?
         .uri()
         .to_string();

server/src/handlers/download.rs

@@ -33,15 +33,15 @@ pub async fn handle_download(
 
     let for_agent = get_client_agent(headers, &appstate, subject.clone())?;
     tracing::info!("handle_download: {}", subject);
-    let file_store = FileStore::get_subject_file_store(&subject);
+    let file_store = FileStore::get_subject_file_store(&appstate.config, &subject);
     let encoded = subject.replace(file_store.prefix(), &file_store.encoded());
     let resource = store.get_resource_extended(&encoded, false, &for_agent)?;
     let file_id = resource
         .get(urls::INTERNAL_ID)
         .map_err(|e| format!("Internal ID of file could not be resolved. {}", e))?
         .to_string();
 
-    if let FileStore::S3 = file_store {
+    if let FileStore::S3(_) = file_store {
         signed_url_redirect_handler(file_id.as_str(), &req, &appstate).await
     } else {
         download_file_handler_partial(file_id.as_str(), &req, &appstate)
@@ -65,7 +65,7 @@ async fn signed_url_redirect_handler(
     req: &HttpRequest,
     appstate: &AppState,
 ) -> AtomicServerResult<HttpResponse> {
-    let signed_url = files::get_s3_signed_url(appstate, Duration::from_secs(3600), file_id).await?;
+    let signed_url = files::get_s3_signed_url(&appstate.config.file_store, Duration::from_secs(3600), file_id).await?;
     Ok(web::Redirect::to(signed_url)
         .respond_to(req)
         .map_into_boxed_body())

server/src/handlers/upload.rs

@@ -85,10 +85,10 @@ pub async fn upload_handler(
             .try_into()
             .map_err(|_e| "Too large")?;
 
-        let file_store = FileStore::get_config_file_store(&appstate.config);
+        let file_store = &appstate.config.file_store;
         let file_id = format!("{}{}", file_store.prefix(), &fs_file_id);
-        if let FileStore::S3 = file_store {
-            files::s3_upload_object(&appstate, &file_id, &file_path).await?;
+        if let FileStore::S3(_) = file_store {
+            files::s3_upload_object(&file_store, &file_id, &file_path).await?;
             fs::remove_file(&file_path)?;
         }