Merge pull request #10 from nuclearcat/add-local-storage

feat: add local storage driver

Author: nuclearcat

config-local.toml

@@ -0,0 +1,5 @@
+driver="local"
+jwt_secret="test-secret-for-local-storage-testing"
+
+[local]
+storage_path="./test-storage"

src/local.rs

@@ -0,0 +1,294 @@
+// SPDX-License-Identifier: LGPL-2.1-or-later
+// Copyright (C) 2024-2025 Collabora, Ltd.
+// Author: Denys Fedoryshchenko <denys.f@collabora.com>
+
+use crate::{get_config_content, ReceivedFile};
+use axum::http::{HeaderName, HeaderValue};
+use chksum_hash_sha2_512 as sha2_512;
+use headers::HeaderMap;
+use serde::Deserialize;
+use std::env;
+use std::fs::{self, File, OpenOptions};
+use std::io::Write;
+use std::path::{Path, PathBuf};
+use toml::Table;
+
+macro_rules! debug_log {
+    ($($arg:tt)*) => {
+        if env::var("STORAGE_DEBUG").is_ok() {
+            println!($($arg)*);
+        }
+    };
+}
+
+pub struct LocalDriver;
+
+impl LocalDriver {
+    pub fn new() -> Self {
+        LocalDriver
+    }
+}
+
+#[derive(Deserialize)]
+struct LocalConfig {
+    storage_path: String,
+}
+
+/// Get local storage configuration from config.toml
+fn get_local_config() -> LocalConfig {
+    let cfg_content = get_config_content();
+    let cfg: Table = toml::from_str(&cfg_content).unwrap();
+    
+    // Default to "./storage" if no local config section exists
+    let default_config = LocalConfig {
+        storage_path: "./storage".to_string(),
+    };
+    
+    let local_cfg = match cfg.get("local") {
+        Some(local_cfg) => local_cfg,
+        None => {
+            debug_log!("No local section in config.toml, using default storage path: ./storage");
+            return default_config;
+        }
+    };
+    
+    let storage_path = local_cfg
+        .get("storage_path")
+        .and_then(|v| v.as_str())
+        .unwrap_or("./storage")
+        .to_string();
+    
+    LocalConfig { storage_path }
+}
+
+/// Create directory structure for a file path
+fn ensure_directory_exists(file_path: &Path) -> Result<(), std::io::Error> {
+    if let Some(parent) = file_path.parent() {
+        fs::create_dir_all(parent)?;
+    }
+    Ok(())
+}
+
+/// Get full file path in storage directory
+fn get_storage_file_path(filename: &str) -> PathBuf {
+    let config = get_local_config();
+    let storage_path = Path::new(&config.storage_path);
+    storage_path.join(filename)
+}
+
+/// Get metadata file path for storing headers
+fn get_metadata_file_path(filename: &str) -> PathBuf {
+    let config = get_local_config();
+    let storage_path = Path::new(&config.storage_path);
+    let metadata_path = storage_path.join(".metadata");
+    
+    // Create metadata directory if it doesn't exist
+    if !metadata_path.exists() {
+        let _ = fs::create_dir_all(&metadata_path);
+    }
+    
+    // Generate hash-based filename for metadata
+    let hash = sha2_512::default().update(filename.as_bytes()).finalize();
+    let digest = hash.digest();
+    metadata_path.join(format!("{}.headers", digest.to_hex_lowercase()))
+}
+
+/// Calculate SHA-512 checksum of file data
+fn calculate_checksum(filename: &str, data: &[u8]) {
+    let hash = sha2_512::default().update(data).finalize();
+    let digest = hash.digest();
+    debug_log!("File: {} Checksum: {}", filename, digest.to_hex_lowercase());
+}
+
+/// Write file to local storage
+fn write_file_to_local(filename: String, data: Vec<u8>, cont_type: String) -> Result<String, String> {
+    let file_path = get_storage_file_path(&filename);
+    
+    // Ensure directory structure exists
+    if let Err(e) = ensure_directory_exists(&file_path) {
+        return Err(format!("Failed to create directory structure: {}", e));
+    }
+    
+    // Write the file
+    match File::create(&file_path) {
+        Ok(mut file) => {
+            if let Err(e) = file.write_all(&data) {
+                return Err(format!("Failed to write file: {}", e));
+            }
+            calculate_checksum(&filename, &data);
+        }
+        Err(e) => {
+            return Err(format!("Failed to create file: {}", e));
+        }
+    }
+    
+    // Create and write metadata (headers)
+    let metadata_path = get_metadata_file_path(&filename);
+    if let Ok(mut metadata_file) = File::create(&metadata_path) {
+        let headers_content = format!("content-type:{}\n", cont_type);
+        let _ = metadata_file.write_all(headers_content.as_bytes());
+    }
+    
+    debug_log!("File written to local storage: {}", file_path.display());
+    Ok(filename)
+}
+
+/// Read headers from metadata file
+fn get_headers_from_metadata_file(filename: &str) -> HeaderMap {
+    let mut headers = HeaderMap::new();
+    let metadata_path = get_metadata_file_path(filename);
+    
+    if let Ok(content) = fs::read_to_string(&metadata_path) {
+        for line in content.lines() {
+            if let Some((name, value)) = line.split_once(':') {
+                if let (Ok(key), Ok(val)) = (
+                    HeaderName::from_bytes(name.trim().as_bytes()),
+                    HeaderValue::from_str(value.trim())
+                ) {
+                    headers.insert(key, val);
+                }
+            }
+        }
+    } else {
+        // Default content-type if metadata file doesn't exist
+        if let Ok(val) = HeaderValue::from_str("application/octet-stream") {
+            headers.insert("content-type", val);
+        }
+    }
+    
+    headers
+}
+
+/// Get file from local storage
+fn get_file_from_local(filename: String) -> ReceivedFile {
+    let file_path = get_storage_file_path(&filename);
+    
+    let mut received_file = ReceivedFile {
+        original_filename: filename.clone(),
+        cached_filename: String::new(),
+        headers: HeaderMap::new(),
+        valid: false,
+    };
+    
+    // Check if file exists
+    if !file_path.exists() {
+        debug_log!("File not found in local storage: {}", file_path.display());
+        return received_file;
+    }
+    
+    // For local storage, we use the same file as both original and cached
+    received_file.cached_filename = file_path.to_string_lossy().to_string();
+    received_file.headers = get_headers_from_metadata_file(&filename);
+    received_file.valid = true;
+    
+    debug_log!("File found in local storage: {}", file_path.display());
+    received_file
+}
+
+/// List files in local storage directory
+fn list_files_in_local(directory: String) -> Vec<String> {
+    let config = get_local_config();
+    let storage_path = Path::new(&config.storage_path);
+    let search_path = if directory == "/" || directory.is_empty() {
+        storage_path.to_path_buf()
+    } else {
+        storage_path.join(directory.trim_start_matches('/'))
+    };
+    
+    let mut files = Vec::new();
+    
+    fn collect_files_recursive(path: &Path, base_path: &Path, files: &mut Vec<String>) {
+        if let Ok(entries) = fs::read_dir(path) {
+            for entry in entries {
+                if let Ok(entry) = entry {
+                    let entry_path = entry.path();
+                    
+                    // Skip metadata directory
+                    if entry_path.file_name().map_or(false, |name| name == ".metadata") {
+                        continue;
+                    }
+                    
+                    if entry_path.is_file() {
+                        // Get relative path from storage root
+                        if let Ok(relative_path) = entry_path.strip_prefix(base_path) {
+                            files.push(relative_path.to_string_lossy().to_string());
+                        }
+                    } else if entry_path.is_dir() {
+                        collect_files_recursive(&entry_path, base_path, files);
+                    }
+                }
+            }
+        }
+    }
+    
+    if search_path.exists() && search_path.is_dir() {
+        collect_files_recursive(&search_path, storage_path, &mut files);
+    }
+    
+    files.sort();
+    debug_log!("Listed {} files from local storage", files.len());
+    files
+}
+
+/// Set tags for local storage (stored in metadata)
+fn set_tags_for_local_file(filename: String, user_tags: Vec<(String, String)>) -> Result<String, String> {
+    let metadata_path = get_metadata_file_path(&filename);
+    
+    // Read existing metadata
+    let mut existing_content = String::new();
+    if metadata_path.exists() {
+        existing_content = fs::read_to_string(&metadata_path)
+            .map_err(|e| format!("Failed to read metadata file: {}", e))?;
+    }
+    
+    // Open metadata file for writing (create if doesn't exist)
+    let mut metadata_file = OpenOptions::new()
+        .create(true)
+        .write(true)
+        .truncate(true)
+        .open(&metadata_path)
+        .map_err(|e| format!("Failed to open metadata file: {}", e))?;
+    
+    // Write existing content first
+    metadata_file.write_all(existing_content.as_bytes())
+        .map_err(|e| format!("Failed to write existing metadata: {}", e))?;
+    
+    // Write tags
+    for (tag, value) in user_tags {
+        let tag_line = format!("tag-{}:{}\n", tag, value);
+        metadata_file.write_all(tag_line.as_bytes())
+            .map_err(|e| format!("Failed to write tag: {}", e))?;
+    }
+    
+    debug_log!("Tags written to metadata file: {}", metadata_path.display());
+    Ok("OK".to_string())
+}
+
+/// Implement Driver trait for LocalDriver
+impl super::Driver for LocalDriver {
+    fn write_file(&self, filename: String, data: Vec<u8>, cont_type: String) -> String {
+        match write_file_to_local(filename.clone(), data, cont_type) {
+            Ok(_) => filename,
+            Err(e) => {
+                eprintln!("Local storage write error: {}", e);
+                String::new()
+            }
+        }
+    }
+    
+    fn get_file(&self, filename: String) -> ReceivedFile {
+        get_file_from_local(filename)
+    }
+    
+    fn tag_file(
+        &self,
+        filename: String,
+        user_tags: Vec<(String, String)>,
+    ) -> Result<String, String> {
+        set_tags_for_local_file(filename, user_tags)
+    }
+    
+    fn list_files(&self, directory: String) -> Vec<String> {
+        list_files_in_local(directory)
+    }
+}

src/main.rs

@@ -11,6 +11,7 @@
 */
 
 mod azure;
+mod local;
 mod storcaching;
 mod storjwt;
 
@@ -116,9 +117,10 @@ trait Driver {
 fn init_driver(driver_type: &str) -> Box<dyn Driver> {
     let driver: Box<dyn Driver> = match driver_type {
         "azure" => Box::new(azure::AzureDriver::new()),
+        "local" => Box::new(local::LocalDriver::new()),
         //"google" => Box::new(google::GoogleDriver::new()),
         _ => {
-            eprintln!("Unknown driver type");
+            eprintln!("Unknown driver type: {}", driver_type);
             std::process::exit(1);
         }
     };
@@ -135,6 +137,17 @@ pub fn get_config_content() -> String {
     std::fs::read_to_string(&cfg_file).unwrap()
 }
 
+/// Get driver type from config.toml, defaults to "azure" for backward compatibility
+fn get_driver_type() -> String {
+    let cfg_content = get_config_content();
+    let cfg: Table = toml::from_str(&cfg_content).unwrap();
+    
+    cfg.get("driver")
+        .and_then(|v| v.as_str())
+        .unwrap_or("azure")
+        .to_string()
+}
+
 /// Initial variables configuration and checks
 async fn initial_setup() -> Option<RustlsConfig> {
     let cache_dir = "cache";
@@ -693,14 +706,14 @@ async fn ax_get_file(
 }
 
 fn driver_get_file(filepath: String) -> ReceivedFile {
-    let driver_name = "azure";
-    let driver = init_driver(driver_name);
+    let driver_name = get_driver_type();
+    let driver = init_driver(&driver_name);
     driver.get_file(filepath)
 }
 
 fn write_file_driver(filename: String, data: Vec<u8>, cont_type: String) -> String {
-    let driver_name = "azure";
-    let driver = init_driver(driver_name);
+    let driver_name = get_driver_type();
+    let driver = init_driver(&driver_name);
     driver.write_file(filename, data, cont_type);
     "".to_string()
 }
@@ -759,8 +772,8 @@ fn verify_auth_hdr(headers: &HeaderMap) -> Result<String, Option<String>> {
 }
 
 async fn ax_list_files() -> (StatusCode, String) {
-    let driver_name = "azure";
-    let driver = init_driver(driver_name);
+    let driver_name = get_driver_type();
+    let driver = init_driver(&driver_name);
     let files = driver.list_files("/".to_string());
     // generate nice list of files, with one file per line
     let files_str = files.join("\n");