move file stores to appstate

Author: metame

server/src/appstate.rs

@@ -1,6 +1,7 @@
 //! App state, which is accessible from handlers
 use crate::{
-    commit_monitor::CommitMonitor, config::Config, errors::AtomicServerResult, search::SearchState,
+    commit_monitor::CommitMonitor, config::Config, errors::AtomicServerResult, files::FileStore,
+    search::SearchState,
 };
 use atomic_lib::{
     agents::{generate_public_key, Agent},
@@ -23,6 +24,10 @@ pub struct AppState {
     /// The Actix Address of the CommitMonitor, which should receive updates when a commit is applied
     pub commit_monitor: actix::Addr<CommitMonitor>,
     pub search_state: SearchState,
+    /// 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,
 }
 
 /// Creates the AppState (the server's context available in Handlers).
@@ -102,11 +107,18 @@ pub fn init(config: Config) -> AtomicServerResult<AppState> {
         crate::search::add_all_resources(&search_state, &store)?
     }
 
+    tracing::info!("Initializing file stores");
+    // Initialize file stores
+    let fs_file_store = FileStore::init_fs_from_config(&config);
+    let file_store = FileStore::init_from_config(&config, fs_file_store.clone());
+
     Ok(AppState {
         store,
         config,
         commit_monitor,
         search_state,
+        file_store,
+        fs_file_store,
     })
 }
 

server/src/config.rs

@@ -1,7 +1,6 @@
 //! 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;
@@ -207,10 +206,6 @@ 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,
 }
@@ -270,10 +265,6 @@ 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, uploads_path.clone());
-    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."
@@ -305,7 +296,5 @@ 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,10 +3,7 @@ use std::{fmt, path::PathBuf, time::Duration};
 use opendal::{services::S3, Operator};
 use tokio::fs::File;
 
-use crate::{
-    config::{Config, Opts},
-    errors::AtomicServerResult,
-};
+use crate::{appstate::AppState, config::Config, errors::AtomicServerResult};
 
 #[derive(Clone, Debug)]
 pub enum FileStore {
@@ -24,18 +21,21 @@ pub struct S3Config {
 
 #[derive(Clone, Debug)]
 pub struct FSConfig {
-    path: PathBuf
+    path: PathBuf,
 }
 
 impl FileStore {
     const S3_PREFIX: &'static str = "s3:";
     const FS_PREFIX: &'static str = "fs:";
 
-    pub fn init_fs_from_config(_opts: &Opts, path: PathBuf) -> FileStore {
-        FileStore::FS(FSConfig {path})
+    pub fn init_fs_from_config(config: &Config) -> FileStore {
+        FileStore::FS(FSConfig {
+            path: config.uploads_path.clone(),
+        })
     }
 
-    pub fn init_from_config(opts: &Opts, fs_file_store: FileStore) -> FileStore {
+    pub fn init_from_config(config: &Config, fs_file_store: FileStore) -> FileStore {
+        let opts = &config.opts;
         if opts.s3_bucket.is_some() {
             let config = S3Config {
                 bucket: opts.s3_bucket.clone().unwrap(),
@@ -49,11 +49,11 @@ impl FileStore {
         }
     }
 
-    pub fn get_subject_file_store<'a>(config: &'a Config, subject: &str) -> &'a FileStore {
+    pub fn get_subject_file_store<'a>(appstate: &'a AppState, subject: &str) -> &'a FileStore {
         if subject.contains(Self::S3_PREFIX) {
-            &config.file_store
+            &appstate.file_store
         } else {
-            &config.fs_file_store
+            &appstate.fs_file_store
         }
     }
 

server/src/handlers/download.rs

@@ -33,7 +33,7 @@ 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(&appstate.config, &subject);
+    let file_store = FileStore::get_subject_file_store(&appstate, &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
@@ -53,7 +53,7 @@ pub fn download_file_handler_partial(
     req: &HttpRequest,
     appstate: &AppState,
 ) -> AtomicServerResult<HttpResponse> {
-    let file_path = appstate.config.fs_file_store.get_fs_file_path(file_id)?;
+    let file_path = appstate.fs_file_store.get_fs_file_path(file_id)?;
     let file = NamedFile::open(file_path)?;
     Ok(file.into_response(req))
 }
@@ -63,12 +63,8 @@ async fn signed_url_redirect_handler(
     req: &HttpRequest,
     appstate: &AppState,
 ) -> AtomicServerResult<HttpResponse> {
-    let signed_url = files::get_s3_signed_url(
-        &appstate.config.file_store,
-        Duration::from_secs(3600),
-        file_id,
-    )
-    .await?;
+    let signed_url =
+        files::get_s3_signed_url(&appstate.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,7 +85,7 @@ pub async fn upload_handler(
             .try_into()
             .map_err(|_e| "Too large")?;
 
-        let file_store = &appstate.config.file_store;
+        let file_store = &appstate.file_store;
         let file_id = format!("{}{}", file_store.prefix(), &fs_file_id);
         if let FileStore::S3(_) = file_store {
             files::s3_upload_object(&file_store, &file_id, &file_path).await?;