cjw/Oxicloud
1
0
Fork 0
Code Issues Pull Requests Actions 4 Packages Projects Releases Wiki Activity

style: apply cargo fmt to entire codebase

Browse Source 
Standardize code formatting across all 173 Rust source files
using rustfmt. No functional changes - purely cosmetic.

This establishes a consistent code style baseline for the
project going forward.
This commit is contained in:
Dionisio
2026-02-14 01:29:34 +01:00
parent 67137a3ef2
commit 4c98c5a657
173 changed files with 23368 additions and 17590 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/application/services/storage_usage_service.rs
+63 -42
View File
@@ -1,14 +1,14 @@
use std::sync::Arc;
use async_trait::async_trait;
use tokio::task;
use crate::common::errors::DomainError;
use crate::application::ports::auth_ports::UserStoragePort;
use crate::application::ports::storage_ports::{FileReadPort, StorageUsagePort};
use tracing::{info, error, debug};
use crate::common::errors::DomainError;
use async_trait::async_trait;
use std::sync::Arc;
use tokio::task;
use tracing::{debug, error, info};
/**
* Service for managing and updating user storage usage statistics.
*
*
* This service is responsible for calculating how much storage each user
* is using and updating this information in the user records.
*/
@@ -28,51 +28,63 @@ impl StorageUsageService {
user_repository,
}
}
/// Calculates and updates storage usage for a specific user
pub async fn update_user_storage_usage(&self, user_id: &str) -> Result<i64, DomainError> {
info!("Updating storage usage for user: {}", user_id);
// Get user's home folder pattern
let user = self.user_repository.get_user_by_id(user_id).await?;
let username = user.username();
// Calculate storage usage for this user
let total_usage = self.calculate_user_storage_usage(username).await?;
// Update the user's storage usage in the database
self.user_repository.update_storage_usage(user_id, total_usage).await?;
info!("Updated storage usage for user {} to {} bytes", user_id, total_usage);
self.user_repository
.update_storage_usage(user_id, total_usage)
.await?;
info!(
"Updated storage usage for user {} to {} bytes",
user_id, total_usage
);
Ok(total_usage)
}
/// Calculates a user's storage usage based on their home folder
async fn calculate_user_storage_usage(&self, username: &str) -> Result<i64, DomainError> {
debug!("Calculating storage for user: {}", username);
// First, try to find the user's home folder
// List all folders to locate the user's folder
let all_folders = self.file_repository.list_files(None).await
let all_folders = self
.file_repository
.list_files(None)
.await
.map_err(|e| DomainError::internal_error("File repository", e.to_string()))?;
// Find the user's home folder (named "My Folder - {username}")
let home_folder_name = format!("My Folder - {}", username);
debug!("Looking for home folder: {}", home_folder_name);
let mut total_usage: i64 = 0;
let mut home_folder_id = None;
// Find the home folder ID
for folder in &all_folders {
if folder.name() == home_folder_name {
home_folder_id = Some(folder.id().to_string());
debug!("Found home folder for user {}: ID={}", username, folder.id());
debug!(
"Found home folder for user {}: ID={}",
username,
folder.id()
);
break;
}
}
// If we found the home folder, calculate total size
if let Some(folder_id) = home_folder_id {
// Calculate recursively
@@ -81,10 +93,10 @@ impl StorageUsageService {
// If no home folder found, just return 0
debug!("No home folder found for user: {}", username);
}
Ok(total_usage)
}
/// Recursively calculates the size of a folder and all its contents
async fn calculate_folder_size(&self, folder_id: &str) -> Result<i64, DomainError> {
// Implementation with explicit boxing to handle recursion in async functions
@@ -93,11 +105,13 @@ impl StorageUsageService {
folder_id: &str,
) -> Result<i64, DomainError> {
let mut total_size: i64 = 0;
// Get files directly in this folder
let files = repo.list_files(Some(folder_id)).await
let files = repo
.list_files(Some(folder_id))
.await
.map_err(|e| DomainError::internal_error("File repository", e.to_string()))?;
// Sum the size of all files
for file in &files {
// Skip subdirectories at this level - we'll process them separately
@@ -105,16 +119,20 @@ impl StorageUsageService {
// Recursively calculate subfolder size with explicit boxing
let subfolder_id = file.id().to_string(); // Create owned copy
let repo_clone = repo.clone(); // Clone the repository
// Use Box::pin to handle recursive async call
let subfolder_size_future = Box::pin(inner_calculate_size(repo_clone, &subfolder_id));
let subfolder_size_future =
Box::pin(inner_calculate_size(repo_clone, &subfolder_id));
match subfolder_size_future.await {
Ok(size) => {
total_size += size;
},
}
Err(e) => {
error!("Error calculating size for subfolder {}: {}", subfolder_id, e);
error!(
"Error calculating size for subfolder {}: {}",
subfolder_id, e
);
// Continue with other folders even if one fails
}
}
@@ -123,10 +141,10 @@ impl StorageUsageService {
total_size += file.size() as i64;
}
}
Ok(total_size)
}
// Start the calculation with a clone of our repository reference
let repo_clone = Arc::clone(&self.file_repository);
inner_calculate_size(repo_clone, folder_id).await
@@ -148,37 +166,40 @@ impl StorageUsagePort for StorageUsageService {
// Get the list of all users
let users = self.user_repository.list_users(1000, 0).await?;
let mut update_tasks = Vec::new();
// Process users in parallel
for user in users {
let user_id = user.id().to_string();
let service_clone = self.clone();
// Spawn a background task for each user
let task = task::spawn(async move {
match service_clone.update_user_storage_usage(&user_id).await {
Ok(usage) => {
debug!("Updated storage usage for user {}: {} bytes", user_id, usage);
debug!(
"Updated storage usage for user {}: {} bytes",
user_id, usage
);
Ok(())
},
}
Err(e) => {
error!("Failed to update storage for user {}: {}", user_id, e);
Err(e)
}
}
});
update_tasks.push(task);
}
// Wait for all tasks to complete
for task in update_tasks {
// We don't propagate errors from individual users to avoid failing the entire batch
let _ = task.await;
}
info!("Completed batch update of all users' storage usage");
Ok(())
}
@@ -192,4 +213,4 @@ impl Clone for StorageUsageService {
user_repository: Arc::clone(&self.user_repository),
}
}
}
}