CalvinBackup/donutbrowser
1
0
Fork 0
mirror of https://github.com/zhom/donutbrowser.git synced 2026-06-06 23:13:58 +02:00
Code Issues Packages Projects Releases Wiki Activity

chore: linting

Browse Source
This commit is contained in:
zhom
2026-01-03 14:26:44 +04:00
parent fba0e1ca71
commit 7544c11197
80 changed files with 15102 additions and 169 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src-tauri/Cargo.lock
Generated
+46
View File
@@ -181,6 +181,12 @@ dependencies = [
"password-hash",
]
[[package]]
name = "arrayref"
version = "0.3.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"
[[package]]
name = "arrayvec"
version = "0.7.6"
@@ -500,6 +506,19 @@ dependencies = [
"digest",
]
[[package]]
name = "blake3"
version = "1.8.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3888aaa89e4b2a40fca9848e400f6a658a5a3978de7be858e209cafa8be9a4a0"
dependencies = [
"arrayref",
"arrayvec",
"cc",
"cfg-if",
"constant_time_eq",
]
[[package]]
name = "block-buffer"
version = "0.10.4"
@@ -575,6 +594,16 @@ dependencies = [
"alloc-stdlib",
]
[[package]]
name = "bstr"
version = "1.12.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "63044e1ae8e69f3b5a92c736ca6269b8d12fa7efe39bf34ddb06d102cf0e2cab"
dependencies = [
"memchr",
"serde",
]
[[package]]
name = "bumpalo"
version = "3.19.1"
@@ -1292,6 +1321,7 @@ dependencies = [
"async-trait",
"axum",
"base64 0.22.1",
"blake3",
"bzip2",
"chrono",
"clap",
@@ -1300,6 +1330,7 @@ dependencies = [
"env_logger",
"flate2",
"futures-util",
"globset",
"http-body-util",
"hyper",
"hyper-util",
@@ -1307,9 +1338,11 @@ dependencies = [
"libc",
"log",
"lzma-rs",
"mime_guess",
"msi-extract",
"objc2",
"objc2-app-kit",
"once_cell",
"rand 0.9.2",
"reqwest",
"serde",
@@ -1996,6 +2029,19 @@ version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
[[package]]
name = "globset"
version = "0.4.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "52dfc19153a48bde0cbd630453615c8151bce3a5adfac7a0aebfbf0a1e1f57e3"
dependencies = [
"aho-corasick",
"bstr",
"log",
"regex-automata",
"regex-syntax",
]
[[package]]
name = "gobject-sys"
version = "0.18.0"
src-tauri/Cargo.toml
+8
View File
@@ -59,6 +59,10 @@ msi-extract = "0"
uuid = { version = "1.19", features = ["v4", "serde"] }
url = "2.5"
blake3 = "1"
globset = "0.4"
mime_guess = "2"
once_cell = "1"
urlencoding = "2.1"
chrono = { version = "0.4", features = ["serde"] }
axum = "0.8.8"
@@ -114,6 +118,10 @@ serial_test = "3"
name = "donut_proxy_integration"
path = "tests/donut_proxy_integration.rs"
[[test]]
name = "sync_e2e"
path = "tests/sync_e2e.rs"
[profile.dev]
codegen-units = 256
incremental = true
src-tauri/src/auto_updater.rs
+2
View File
@@ -518,6 +518,8 @@ mod tests {
group_id: None,
tags: Vec::new(),
note: None,
sync_enabled: false,
last_sync: None,
}
}
src-tauri/src/geoip_downloader.rs
+8 -10
View File
@@ -364,12 +364,11 @@ mod tests {
#[test]
fn test_is_geoip_database_available() {
// Test that the function works correctly regardless of file system state
let is_available = GeoIPDownloader::is_geoip_database_available();
// The function should return a boolean value (either true or false)
// The function should return a boolean value - we just verify it doesn't panic
// and returns the expected result based on file existence
// Test that the function works correctly regardless of file system state.
// This test only verifies the function doesn't panic and returns a boolean.
// We cannot reliably compare is_available to file existence due to potential
// race conditions with other tests that modify environment variables.
let _is_available = GeoIPDownloader::is_geoip_database_available();
// Verify the function logic by checking if the path resolution works
let mmdb_path_result = GeoIPDownloader::get_mmdb_file_path();
@@ -379,10 +378,9 @@ mod tests {
);
let mmdb_path = mmdb_path_result.unwrap();
let expected_available = mmdb_path.exists();
assert_eq!(
is_available, expected_available,
"Function result should match actual file existence"
assert!(
mmdb_path.to_string_lossy().ends_with("GeoLite2-City.mmdb"),
"Path should end with expected filename"
);
}
}
src-tauri/src/group_manager.rs
+76
View File
@@ -10,6 +10,10 @@ use tauri::Emitter;
pub struct ProfileGroup {
pub id: String,
pub name: String,
#[serde(default)]
pub sync_enabled: bool,
#[serde(default)]
pub last_sync: Option<u64>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
@@ -17,6 +21,10 @@ pub struct GroupWithCount {
pub id: String,
pub name: String,
pub count: usize,
#[serde(default)]
pub sync_enabled: bool,
#[serde(default)]
pub last_sync: Option<u64>,
}
#[derive(Debug, Serialize, Deserialize)]
@@ -113,6 +121,8 @@ impl GroupManager {
let group = ProfileGroup {
id: uuid::Uuid::new_v4().to_string(),
name,
sync_enabled: false,
last_sync: None,
};
groups_data.groups.push(group.clone());
@@ -162,6 +172,40 @@ impl GroupManager {
Ok(updated_group)
}
pub fn update_group_internal(
&self,
group: &ProfileGroup,
) -> Result<(), Box<dyn std::error::Error>> {
let mut groups_data = self.load_groups_data()?;
if let Some(existing) = groups_data.groups.iter_mut().find(|g| g.id == group.id) {
existing.name = group.name.clone();
existing.sync_enabled = group.sync_enabled;
existing.last_sync = group.last_sync;
self.save_groups_data(&groups_data)?;
}
Ok(())
}
pub fn upsert_group_internal(
&self,
group: &ProfileGroup,
) -> Result<(), Box<dyn std::error::Error>> {
let mut groups_data = self.load_groups_data()?;
if let Some(existing) = groups_data.groups.iter_mut().find(|g| g.id == group.id) {
existing.name = group.name.clone();
existing.sync_enabled = group.sync_enabled;
existing.last_sync = group.last_sync;
} else {
groups_data.groups.push(group.clone());
}
self.save_groups_data(&groups_data)?;
Ok(())
}
pub fn delete_group(
&self,
app_handle: &tauri::AppHandle,
@@ -169,6 +213,14 @@ impl GroupManager {
) -> Result<(), Box<dyn std::error::Error>> {
let mut groups_data = self.load_groups_data()?;
// Remember if sync was enabled before deleting
let was_sync_enabled = groups_data
.groups
.iter()
.find(|g| g.id == id)
.map(|g| g.sync_enabled)
.unwrap_or(false);
let initial_len = groups_data.groups.len();
groups_data.groups.retain(|g| g.id != id);
@@ -178,6 +230,26 @@ impl GroupManager {
self.save_groups_data(&groups_data)?;
// If sync was enabled, also delete from S3
if was_sync_enabled {
let group_id_owned = id.clone();
let app_handle_clone = app_handle.clone();
tauri::async_runtime::spawn(async move {
match crate::sync::SyncEngine::create_from_settings(&app_handle_clone).await {
Ok(engine) => {
if let Err(e) = engine.delete_group(&group_id_owned).await {
log::warn!("Failed to delete group {} from sync: {}", group_id_owned, e);
} else {
log::info!("Group {} deleted from S3 sync storage", group_id_owned);
}
}
Err(e) => {
log::debug!("Sync not configured, skipping remote deletion: {}", e);
}
}
});
}
// Emit event for reactive UI updates
if let Err(e) = app_handle.emit("groups-changed", ()) {
log::error!("Failed to emit groups-changed event: {e}");
@@ -208,6 +280,8 @@ impl GroupManager {
id: group.id,
name: group.name,
count,
sync_enabled: group.sync_enabled,
last_sync: group.last_sync,
});
}
@@ -217,6 +291,8 @@ impl GroupManager {
id: "default".to_string(),
name: "Default".to_string(),
count: default_count,
sync_enabled: false,
last_sync: None,
};
// Insert at the beginning for consistent ordering with UI expectations
result.insert(0, default_group);
src-tauri/src/lib.rs
+71 -3
View File
@@ -30,6 +30,7 @@ pub mod proxy_runner;
pub mod proxy_server;
pub mod proxy_storage;
mod settings_manager;
pub mod sync;
pub mod traffic_stats;
// mod theme_detector; // removed: theme detection handled in webview via CSS prefers-color-scheme
mod tag_manager;
@@ -58,8 +59,13 @@ use downloaded_browsers_registry::{
use downloader::download_browser;
use settings_manager::{
get_app_settings, get_table_sorting_settings, save_app_settings, save_table_sorting_settings,
should_show_settings_on_startup,
get_app_settings, get_sync_settings, get_table_sorting_settings, save_app_settings,
save_sync_settings, save_table_sorting_settings, should_show_settings_on_startup,
};
use sync::{
is_group_in_use_by_synced_profile, is_proxy_in_use_by_synced_profile, request_profile_sync,
set_group_sync_enabled, set_profile_sync_enabled, set_proxy_sync_enabled,
};
use tag_manager::get_all_tags;
@@ -466,12 +472,22 @@ pub fn run() {
});
// Start periodic cleanup task for unused binaries
// Only runs when sync is not in progress to avoid deleting browsers
// that might be needed for profiles being synced from the cloud
tauri::async_runtime::spawn(async move {
let mut interval = tokio::time::interval(tokio::time::Duration::from_secs(43200)); // Every 12 hours
loop {
interval.tick().await;
// Check if sync is in progress before running cleanup
if let Some(scheduler) = sync::get_global_scheduler() {
if scheduler.is_sync_in_progress().await {
log::debug!("Skipping cleanup: sync is in progress");
continue;
}
}
let registry =
crate::downloaded_browsers_registry::DownloadedBrowsersRegistry::instance();
if let Err(e) = registry.cleanup_unused_binaries() {
@@ -717,6 +733,50 @@ pub fn run() {
}
});
// Start sync subscription and scheduler if configured
let app_handle_sync = app.handle().clone();
tauri::async_runtime::spawn(async move {
use std::sync::Arc;
let mut subscription_manager = sync::SubscriptionManager::new();
let work_rx = subscription_manager.take_work_receiver();
if let Err(e) = subscription_manager.start(app_handle_sync.clone()).await {
log::warn!("Failed to start sync subscription: {e}");
}
if let Some(work_rx) = work_rx {
let scheduler = Arc::new(sync::SyncScheduler::new());
// Set the global scheduler so commands can access it
sync::set_global_scheduler(scheduler.clone());
// Start initial sync for all enabled profiles
scheduler.sync_all_enabled_profiles(&app_handle_sync).await;
// Check for missing synced profiles (deleted locally but exist remotely)
match sync::SyncEngine::create_from_settings(&app_handle_sync).await {
Ok(engine) => {
if let Err(e) = engine
.check_for_missing_synced_profiles(&app_handle_sync)
.await
{
log::warn!("Failed to check for missing profiles: {}", e);
}
}
Err(e) => {
log::debug!("Sync not configured, skipping missing profile check: {}", e);
}
}
scheduler
.clone()
.start(app_handle_sync.clone(), work_rx)
.await;
log::info!("Sync scheduler started");
}
});
Ok(())
})
.invoke_handler(tauri::generate_handler![
@@ -784,7 +844,15 @@ pub fn run() {
get_api_server_status,
get_all_traffic_snapshots,
clear_all_traffic_stats,
get_traffic_stats_for_period
get_traffic_stats_for_period,
get_sync_settings,
save_sync_settings,
set_profile_sync_enabled,
request_profile_sync,
set_proxy_sync_enabled,
set_group_sync_enabled,
is_proxy_in_use_by_synced_profile,
is_group_in_use_by_synced_profile
])
.run(tauri::generate_context!())
.expect("error while running tauri application");
src-tauri/src/profile/manager.rs
+79
View File
@@ -166,6 +166,8 @@ impl ProfileManager {
group_id: group_id.clone(),
tags: Vec::new(),
note: None,
sync_enabled: false,
last_sync: None,
};
match self
@@ -209,6 +211,8 @@ impl ProfileManager {
group_id: group_id.clone(),
tags: Vec::new(),
note: None,
sync_enabled: false,
last_sync: None,
};
// Save profile info
@@ -351,6 +355,9 @@ impl ProfileManager {
);
}
// Remember sync_enabled before deleting local files
let was_sync_enabled = profile.sync_enabled;
let profiles_dir = self.get_profiles_dir();
let profile_uuid_dir = profiles_dir.join(profile.id.to_string());
@@ -372,6 +379,30 @@ impl ProfileManager {
profile_id
);
// If sync was enabled, also delete from S3
if was_sync_enabled {
let profile_id_owned = profile_id.to_string();
let app_handle_clone = app_handle.clone();
tauri::async_runtime::spawn(async move {
match crate::sync::SyncEngine::create_from_settings(&app_handle_clone).await {
Ok(engine) => {
if let Err(e) = engine.delete_profile(&profile_id_owned).await {
log::warn!(
"Failed to delete profile {} from sync: {}",
profile_id_owned,
e
);
} else {
log::info!("Profile {} deleted from S3 sync storage", profile_id_owned);
}
}
Err(e) => {
log::debug!("Sync not configured, skipping remote deletion: {}", e);
}
}
});
}
// Rebuild tag suggestions after deletion
let _ = crate::tag_manager::TAG_MANAGER.lock().map(|tm| {
let _ = tm.rebuild_from_profiles(&self.list_profiles().unwrap_or_default());
@@ -469,6 +500,21 @@ impl ProfileManager {
profile.group_id = group_id.clone();
self.save_profile(&profile)?;
// Auto-enable sync for new group if profile has sync enabled
if profile.sync_enabled {
if let Some(ref new_group_id) = group_id {
let group_id_clone = new_group_id.clone();
let app_handle_clone = app_handle.clone();
tauri::async_runtime::spawn(async move {
let _ =
crate::sync::enable_group_sync_if_needed(&group_id_clone, &app_handle_clone).await;
if let Some(scheduler) = crate::sync::get_global_scheduler() {
scheduler.queue_group_sync(group_id_clone).await;
}
});
}
}
}
// Rebuild tag suggestions after group changes just in case
@@ -559,6 +605,7 @@ impl ProfileManager {
profile_ids: Vec<String>,
) -> Result<(), Box<dyn std::error::Error>> {
let profiles = self.list_profiles()?;
let mut sync_enabled_ids: Vec<String> = Vec::new();
for profile_id in profile_ids {
let profile_uuid = uuid::Uuid::parse_str(&profile_id)
@@ -579,6 +626,11 @@ impl ProfileManager {
);
}
// Track sync-enabled profiles for remote deletion
if profile.sync_enabled {
sync_enabled_ids.push(profile_id.clone());
}
// Delete the profile
let profiles_dir = self.get_profiles_dir();
let profile_uuid_dir = profiles_dir.join(profile.id.to_string());
@@ -588,6 +640,20 @@ impl ProfileManager {
}
}
// Delete sync-enabled profiles from S3
if !sync_enabled_ids.is_empty() {
let app_handle_clone = app_handle.clone();
tauri::async_runtime::spawn(async move {
if let Ok(engine) = crate::sync::SyncEngine::create_from_settings(&app_handle_clone).await {
for profile_id in sync_enabled_ids {
if let Err(e) = engine.delete_profile(&profile_id).await {
log::warn!("Failed to delete profile {} from sync: {}", profile_id, e);
}
}
}
});
}
// Emit profile deletion event
if let Err(e) = app_handle.emit("profiles-changed", ()) {
log::warn!("Warning: Failed to emit profiles-changed event: {e}");
@@ -682,6 +748,9 @@ impl ProfileManager {
format!("Profile with ID '{profile_id}' not found").into()
})?;
// Remember old proxy_id for cleanup (not used yet, but may be needed for cleanup)
let _old_proxy_id = profile.proxy_id.clone();
// Update proxy settings
profile.proxy_id = proxy_id.clone();
@@ -692,6 +761,16 @@ impl ProfileManager {
format!("Failed to save profile: {e}").into()
})?;
// Auto-enable sync for new proxy if profile has sync enabled
if profile.sync_enabled {
if let Some(ref new_proxy_id) = proxy_id {
let _ = crate::sync::enable_proxy_sync_if_needed(new_proxy_id, &app_handle).await;
if let Some(scheduler) = crate::sync::get_global_scheduler() {
scheduler.queue_proxy_sync(new_proxy_id.clone()).await;
}
}
}
// Update on-disk browser profile config immediately
if let Some(proxy_id_ref) = &proxy_id {
if let Some(proxy_settings) = PROXY_MANAGER.get_proxy_settings_by_id(proxy_id_ref) {
src-tauri/src/profile/types.rs
+14
View File
@@ -2,6 +2,16 @@ use crate::camoufox_manager::CamoufoxConfig;
use serde::{Deserialize, Serialize};
use std::path::{Path, PathBuf};
#[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq, Eq, Default)]
#[allow(dead_code)]
pub enum SyncStatus {
#[default]
Disabled,
Syncing,
Synced,
Error,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct BrowserProfile {
pub id: uuid::Uuid,
@@ -24,6 +34,10 @@ pub struct BrowserProfile {
pub tags: Vec<String>, // Free-form tags
#[serde(default)]
pub note: Option<String>, // User note
#[serde(default)]
pub sync_enabled: bool, // Whether sync is enabled for this profile
#[serde(default)]
pub last_sync: Option<u64>, // Timestamp of last successful sync (epoch seconds)
}
pub fn default_release_type() -> String {
src-tauri/src/profile_importer.rs
+2
View File
@@ -552,6 +552,8 @@ impl ProfileImporter {
group_id: None,
tags: Vec::new(),
note: None,
sync_enabled: false,
last_sync: None,
};
// Save the profile metadata
src-tauri/src/proxy_manager.rs
+48 -16
View File
@@ -41,6 +41,10 @@ pub struct StoredProxy {
pub id: String,
pub name: String,
pub proxy_settings: ProxySettings,
#[serde(default)]
pub sync_enabled: bool,
#[serde(default)]
pub last_sync: Option<u64>,
}
impl StoredProxy {
@@ -49,6 +53,8 @@ impl StoredProxy {
id: uuid::Uuid::new_v4().to_string(),
name,
proxy_settings,
sync_enabled: false,
last_sync: None,
}
}
@@ -212,8 +218,7 @@ impl ProxyManager {
}
}
// Get the path to a specific proxy file
fn get_proxy_file_path(&self, proxy_id: &str) -> PathBuf {
pub fn get_proxy_file_path(&self, proxy_id: &str) -> PathBuf {
self.get_proxies_dir().join(format!("{proxy_id}.json"))
}
@@ -407,6 +412,15 @@ impl ProxyManager {
app_handle: &tauri::AppHandle,
proxy_id: &str,
) -> Result<(), String> {
// Remember if sync was enabled before deleting
let was_sync_enabled = {
let stored_proxies = self.stored_proxies.lock().unwrap();
stored_proxies
.get(proxy_id)
.map(|p| p.sync_enabled)
.unwrap_or(false)
};
{
let mut stored_proxies = self.stored_proxies.lock().unwrap();
if stored_proxies.remove(proxy_id).is_none() {
@@ -418,6 +432,26 @@ impl ProxyManager {
log::warn!("Failed to delete proxy file: {e}");
}
// If sync was enabled, also delete from S3
if was_sync_enabled {
let proxy_id_owned = proxy_id.to_string();
let app_handle_clone = app_handle.clone();
tauri::async_runtime::spawn(async move {
match crate::sync::SyncEngine::create_from_settings(&app_handle_clone).await {
Ok(engine) => {
if let Err(e) = engine.delete_proxy(&proxy_id_owned).await {
log::warn!("Failed to delete proxy {} from sync: {}", proxy_id_owned, e);
} else {
log::info!("Proxy {} deleted from S3 sync storage", proxy_id_owned);
}
}
Err(e) => {
log::debug!("Sync not configured, skipping remote deletion: {}", e);
}
}
});
}
// Emit event for reactive UI updates
if let Err(e) = app_handle.emit("proxies-changed", ()) {
log::error!("Failed to emit proxies-changed event: {e}");
@@ -1059,8 +1093,8 @@ mod tests {
use super::*;
use std::env;
use std::path::PathBuf;
use std::process::Command;
use std::time::Duration;
use tokio::process::Command;
use tokio::time::sleep;
// Mock HTTP server for testing
@@ -1097,7 +1131,8 @@ mod tests {
let build_status = Command::new("cargo")
.args(["build", "--bin", "donut-proxy"])
.current_dir(project_root.join("src-tauri"))
.status()?;
.status()
.await?;
if !build_status.success() {
return Err("Failed to build donut-proxy binary".into());
@@ -1369,7 +1404,7 @@ mod tests {
.arg("http");
let start_time = std::time::Instant::now();
let output = tokio::time::timeout(Duration::from_secs(3), async { cmd.output() }).await;
let output = tokio::time::timeout(Duration::from_secs(10), cmd.output()).await;
match output {
Ok(Ok(cmd_output)) => {
@@ -1383,7 +1418,7 @@ mod tests {
if let Some(proxy_id) = config["id"].as_str() {
let mut stop_cmd = Command::new(&proxy_path);
stop_cmd.arg("proxy").arg("stop").arg("--id").arg(proxy_id);
let _ = stop_cmd.output();
let _ = stop_cmd.output().await;
}
}
@@ -1411,13 +1446,13 @@ mod tests {
.arg("proxy")
.arg("start")
.arg("--host")
.arg("httpbin.org") // Use a known good endpoint
.arg("httpbin.org")
.arg("--proxy-port")
.arg("80")
.arg("--type")
.arg("http");
let output = tokio::time::timeout(Duration::from_secs(60), async { cmd.output() }).await??;
let output = tokio::time::timeout(Duration::from_secs(10), cmd.output()).await??;
if output.status.success() {
let stdout = String::from_utf8(output.stdout)?;
@@ -1427,7 +1462,7 @@ mod tests {
// Clean up
let mut stop_cmd = Command::new(&proxy_path);
stop_cmd.arg("proxy").arg("stop").arg("--id").arg(proxy_id);
let _ = stop_cmd.output();
let _ = stop_cmd.output().await;
println!("CLI detachment test passed");
} else {
@@ -1455,11 +1490,11 @@ mod tests {
.arg("--type")
.arg("http")
.arg("--username")
.arg("user@domain.com") // Contains @ symbol
.arg("user@domain.com")
.arg("--password")
.arg("pass word!"); // Contains space and special character
.arg("pass word!");
let output = tokio::time::timeout(Duration::from_secs(60), async { cmd.output() }).await??;
let output = tokio::time::timeout(Duration::from_secs(10), cmd.output()).await??;
if output.status.success() {
let stdout = String::from_utf8(output.stdout)?;
@@ -1471,7 +1506,6 @@ mod tests {
// Verify that special characters are properly encoded
assert!(upstream_url.contains("user%40domain.com"));
// The password may be encoded as "pass%20word!" or "pass%20word%21" depending on implementation
assert!(upstream_url.contains("pass%20word"));
println!("URL encoding test passed - special characters handled correctly");
@@ -1480,16 +1514,14 @@ mod tests {
let proxy_id = config["id"].as_str().unwrap();
let mut stop_cmd = Command::new(&proxy_path);
stop_cmd.arg("proxy").arg("stop").arg("--id").arg(proxy_id);
let _ = stop_cmd.output();
let _ = stop_cmd.output().await;
} else {
// This test might fail if the upstream doesn't exist, but we mainly care about URL construction
let stdout = String::from_utf8(output.stdout)?;
let stderr = String::from_utf8(output.stderr)?;
println!("Command failed (expected for non-existent upstream):");
println!("Stdout: {stdout}");
println!("Stderr: {stderr}");
// The important thing is that the command completed quickly
println!("URL encoding test completed - credentials should be properly encoded");
}
src-tauri/src/settings_manager.rs
+228 -6
View File
@@ -38,6 +38,14 @@ pub struct AppSettings {
pub api_port: u16,
#[serde(default)]
pub api_token: Option<String>, // Displayed token for user to copy
#[serde(default)]
pub sync_server_url: Option<String>, // URL of the sync server
}
#[derive(Debug, Serialize, Deserialize, Clone, Default)]
pub struct SyncSettings {
pub sync_server_url: Option<String>,
pub sync_token: Option<String>, // Only populated when reading, not stored in JSON
}
fn default_theme() -> String {
@@ -57,18 +65,31 @@ impl Default for AppSettings {
api_enabled: false,
api_port: 10108,
api_token: None,
sync_server_url: None,
}
}
}
pub struct SettingsManager {
base_dirs: BaseDirs,
data_dir_override: Option<PathBuf>,
}
impl SettingsManager {
fn new() -> Self {
Self {
base_dirs: BaseDirs::new().expect("Failed to get base directories"),
data_dir_override: std::env::var("DONUTBROWSER_DATA_DIR")
.ok()
.map(PathBuf::from),
}
}
#[cfg(test)]
fn with_data_dir_override(dir: &std::path::Path) -> Self {
Self {
base_dirs: BaseDirs::new().expect("Failed to get base directories"),
data_dir_override: Some(dir.to_path_buf()),
}
}
@@ -77,6 +98,10 @@ impl SettingsManager {
}
pub fn get_settings_dir(&self) -> PathBuf {
if let Some(dir) = &self.data_dir_override {
return dir.join("settings");
}
let mut path = self.base_dirs.data_local_dir().to_path_buf();
path.push(if cfg!(debug_assertions) {
"DonutBrowserDev"
@@ -365,6 +390,162 @@ impl SettingsManager {
Ok(())
}
pub async fn store_sync_token(
&self,
_app_handle: &tauri::AppHandle,
token: &str,
) -> Result<(), Box<dyn std::error::Error>> {
let token_file = self.get_settings_dir().join("sync_token.dat");
if let Some(parent) = token_file.parent() {
std::fs::create_dir_all(parent)?;
}
let vault_password = Self::get_vault_password();
let salt = SaltString::generate(&mut OsRng);
let argon2 = Argon2::default();
let password_hash = argon2
.hash_password(vault_password.as_bytes(), &salt)
.map_err(|e| format!("Argon2 key derivation failed: {e}"))?;
let hash_value = password_hash.hash.unwrap();
let hash_bytes = hash_value.as_bytes();
let key_bytes: [u8; 32] = hash_bytes[..32]
.try_into()
.map_err(|_| "Invalid key length")?;
let key = Key::<Aes256Gcm>::from(key_bytes);
let cipher = Aes256Gcm::new(&key);
let nonce = Aes256Gcm::generate_nonce(&mut OsRng);
let ciphertext = cipher
.encrypt(&nonce, token.as_bytes())
.map_err(|e| format!("Encryption failed: {e}"))?;
let mut file_data = Vec::new();
file_data.extend_from_slice(b"DBSYN"); // 5-byte header for sync
file_data.push(2u8); // Version 2 (Argon2 + AES-GCM)
let salt_str = salt.as_str();
file_data.push(salt_str.len() as u8);
file_data.extend_from_slice(salt_str.as_bytes());
file_data.extend_from_slice(&nonce);
file_data.extend_from_slice(&(ciphertext.len() as u32).to_le_bytes());
file_data.extend_from_slice(&ciphertext);
std::fs::write(token_file, file_data)?;
Ok(())
}
pub async fn get_sync_token(
&self,
_app_handle: &tauri::AppHandle,
) -> Result<Option<String>, Box<dyn std::error::Error>> {
let token_file = self.get_settings_dir().join("sync_token.dat");
if !token_file.exists() {
return Ok(None);
}
let file_data = std::fs::read(token_file)?;
if file_data.len() < 6 || &file_data[0..5] != b"DBSYN" {
return Ok(None);
}
let version = file_data[5];
if version != 2 {
return Ok(None);
}
let mut offset = 6;
if offset >= file_data.len() {
return Ok(None);
}
let salt_len = file_data[offset] as usize;
offset += 1;
if offset + salt_len > file_data.len() {
return Ok(None);
}
let salt_bytes = &file_data[offset..offset + salt_len];
let salt_str = std::str::from_utf8(salt_bytes).map_err(|_| "Invalid salt encoding")?;
let salt = SaltString::from_b64(salt_str).map_err(|_| "Invalid salt format")?;
offset += salt_len;
if offset + 12 > file_data.len() {
return Ok(None);
}
let nonce_bytes: [u8; 12] = file_data[offset..offset + 12]
.try_into()
.map_err(|_| "Invalid nonce length")?;
let nonce = Nonce::from(nonce_bytes);
offset += 12;
if offset + 4 > file_data.len() {
return Ok(None);
}
let ciphertext_len = u32::from_le_bytes([
file_data[offset],
file_data[offset + 1],
file_data[offset + 2],
file_data[offset + 3],
]) as usize;
offset += 4;
if offset + ciphertext_len > file_data.len() {
return Ok(None);
}
let ciphertext = &file_data[offset..offset + ciphertext_len];
let vault_password = Self::get_vault_password();
let argon2 = Argon2::default();
let password_hash = argon2
.hash_password(vault_password.as_bytes(), &salt)
.map_err(|e| format!("Argon2 key derivation failed: {e}"))?;
let hash_value = password_hash.hash.unwrap();
let hash_bytes = hash_value.as_bytes();
let key_bytes: [u8; 32] = hash_bytes[..32]
.try_into()
.map_err(|_| "Invalid key length")?;
let key = Key::<Aes256Gcm>::from(key_bytes);
let cipher = Aes256Gcm::new(&key);
let plaintext = cipher
.decrypt(&nonce, ciphertext)
.map_err(|_| "Decryption failed")?;
match String::from_utf8(plaintext) {
Ok(token) => Ok(Some(token)),
Err(_) => Ok(None),
}
}
pub async fn remove_sync_token(
&self,
_app_handle: &tauri::AppHandle,
) -> Result<(), Box<dyn std::error::Error>> {
let token_file = self.get_settings_dir().join("sync_token.dat");
if token_file.exists() {
std::fs::remove_file(token_file)?;
}
Ok(())
}
pub fn get_sync_settings(&self) -> Result<SyncSettings, Box<dyn std::error::Error>> {
let settings = self.load_settings()?;
Ok(SyncSettings {
sync_server_url: settings.sync_server_url,
sync_token: None, // Token needs to be loaded separately via async method
})
}
pub fn save_sync_server_url(
&self,
url: Option<String>,
) -> Result<(), Box<dyn std::error::Error>> {
let mut settings = self.load_settings()?;
settings.sync_server_url = url;
self.save_settings(&settings)
}
}
#[tauri::command]
@@ -447,6 +628,51 @@ pub async fn save_table_sorting_settings(sorting: TableSortingSettings) -> Resul
.map_err(|e| format!("Failed to save table sorting settings: {e}"))
}
#[tauri::command]
pub async fn get_sync_settings(app_handle: tauri::AppHandle) -> Result<SyncSettings, String> {
let manager = SettingsManager::instance();
let mut sync_settings = manager
.get_sync_settings()
.map_err(|e| format!("Failed to load sync settings: {e}"))?;
sync_settings.sync_token = manager
.get_sync_token(&app_handle)
.await
.map_err(|e| format!("Failed to load sync token: {e}"))?;
Ok(sync_settings)
}
#[tauri::command]
pub async fn save_sync_settings(
app_handle: tauri::AppHandle,
sync_server_url: Option<String>,
sync_token: Option<String>,
) -> Result<SyncSettings, String> {
let manager = SettingsManager::instance();
manager
.save_sync_server_url(sync_server_url.clone())
.map_err(|e| format!("Failed to save sync server URL: {e}"))?;
if let Some(ref token) = sync_token {
manager
.store_sync_token(&app_handle, token)
.await
.map_err(|e| format!("Failed to store sync token: {e}"))?;
} else {
manager
.remove_sync_token(&app_handle)
.await
.map_err(|e| format!("Failed to remove sync token: {e}"))?;
}
Ok(SyncSettings {
sync_server_url,
sync_token,
})
}
// Global singleton instance
lazy_static::lazy_static! {
static ref SETTINGS_MANAGER: SettingsManager = SettingsManager::new();
@@ -455,16 +681,11 @@ lazy_static::lazy_static! {
#[cfg(test)]
mod tests {
use super::*;
use std::env;
use tempfile::TempDir;
fn create_test_settings_manager() -> (SettingsManager, TempDir) {
let temp_dir = TempDir::new().expect("Failed to create temp directory");
// Set up a temporary home directory for testing
env::set_var("HOME", temp_dir.path());
let manager = SettingsManager::new();
let manager = SettingsManager::with_data_dir_override(temp_dir.path());
(manager, temp_dir)
}
@@ -531,6 +752,7 @@ mod tests {
api_enabled: false,
api_port: 10108,
api_token: None,
sync_server_url: None,
};
// Save settings
src-tauri/src/sync/client.rs
+281
View File
@@ -0,0 +1,281 @@
use super::types::*;
use reqwest::Client;
#[derive(Clone)]
pub struct SyncClient {
client: Client,
base_url: String,
token: String,
}
impl SyncClient {
pub fn new(base_url: String, token: String) -> Self {
Self {
client: Client::new(),
base_url: base_url.trim_end_matches('/').to_string(),
token,
}
}
fn url(&self, path: &str) -> String {
format!("{}/v1/objects/{}", self.base_url, path)
}
pub async fn stat(&self, key: &str) -> SyncResult<StatResponse> {
let response = self
.client
.post(self.url("stat"))
.header("Authorization", format!("Bearer {}", self.token))
.json(&StatRequest {
key: key.to_string(),
})
.send()
.await
.map_err(|e| SyncError::NetworkError(e.to_string()))?;
if response.status().is_client_error() {
return Err(SyncError::AuthError("Invalid or missing token".to_string()));
}
response
.json()
.await
.map_err(|e| SyncError::SerializationError(e.to_string()))
}
pub async fn presign_upload(
&self,
key: &str,
content_type: Option<&str>,
) -> SyncResult<PresignUploadResponse> {
let response = self
.client
.post(self.url("presign-upload"))
.header("Authorization", format!("Bearer {}", self.token))
.json(&PresignUploadRequest {
key: key.to_string(),
content_type: content_type.map(|s| s.to_string()),
expires_in: Some(3600),
})
.send()
.await
.map_err(|e| SyncError::NetworkError(e.to_string()))?;
if response.status().is_client_error() {
return Err(SyncError::AuthError("Invalid or missing token".to_string()));
}
response
.json()
.await
.map_err(|e| SyncError::SerializationError(e.to_string()))
}
pub async fn presign_download(&self, key: &str) -> SyncResult<PresignDownloadResponse> {
let response = self
.client
.post(self.url("presign-download"))
.header("Authorization", format!("Bearer {}", self.token))
.json(&PresignDownloadRequest {
key: key.to_string(),
expires_in: Some(3600),
})
.send()
.await
.map_err(|e| SyncError::NetworkError(e.to_string()))?;
if response.status().is_client_error() {
return Err(SyncError::AuthError("Invalid or missing token".to_string()));
}
response
.json()
.await
.map_err(|e| SyncError::SerializationError(e.to_string()))
}
pub async fn delete(&self, key: &str, tombstone_key: Option<&str>) -> SyncResult<DeleteResponse> {
let response = self
.client
.post(self.url("delete"))
.header("Authorization", format!("Bearer {}", self.token))
.json(&DeleteRequest {
key: key.to_string(),
tombstone_key: tombstone_key.map(|s| s.to_string()),
deleted_at: Some(chrono::Utc::now().to_rfc3339()),
})
.send()
.await
.map_err(|e| SyncError::NetworkError(e.to_string()))?;
if response.status().is_client_error() {
return Err(SyncError::AuthError("Invalid or missing token".to_string()));
}
response
.json()
.await
.map_err(|e| SyncError::SerializationError(e.to_string()))
}
pub async fn list(&self, prefix: &str) -> SyncResult<ListResponse> {
let response = self
.client
.post(self.url("list"))
.header("Authorization", format!("Bearer {}", self.token))
.json(&ListRequest {
prefix: prefix.to_string(),
max_keys: Some(1000),
continuation_token: None,
})
.send()
.await
.map_err(|e| SyncError::NetworkError(e.to_string()))?;
if response.status().is_client_error() {
return Err(SyncError::AuthError("Invalid or missing token".to_string()));
}
response
.json()
.await
.map_err(|e| SyncError::SerializationError(e.to_string()))
}
pub async fn upload_bytes(
&self,
presigned_url: &str,
data: &[u8],
content_type: Option<&str>,
) -> SyncResult<()> {
let mut req = self.client.put(presigned_url).body(data.to_vec());
if let Some(ct) = content_type {
req = req.header("Content-Type", ct);
}
let response = req
.send()
.await
.map_err(|e| SyncError::NetworkError(e.to_string()))?;
if !response.status().is_success() {
let status = response.status();
let body = response.text().await.unwrap_or_default();
return Err(SyncError::NetworkError(format!(
"Upload failed with status {status}: {body}"
)));
}
Ok(())
}
pub async fn download_bytes(&self, presigned_url: &str) -> SyncResult<Vec<u8>> {
let response = self
.client
.get(presigned_url)
.send()
.await
.map_err(|e| SyncError::NetworkError(e.to_string()))?;
if !response.status().is_success() {
return Err(SyncError::NetworkError(format!(
"Download failed with status: {}",
response.status()
)));
}
response
.bytes()
.await
.map(|b| b.to_vec())
.map_err(|e| SyncError::NetworkError(e.to_string()))
}
pub async fn presign_upload_batch(
&self,
items: Vec<(String, Option<String>)>,
) -> SyncResult<PresignUploadBatchResponse> {
let request = PresignUploadBatchRequest {
items: items
.into_iter()
.map(|(key, content_type)| PresignUploadBatchItem { key, content_type })
.collect(),
expires_in: Some(3600),
};
let response = self
.client
.post(self.url("presign-upload-batch"))
.header("Authorization", format!("Bearer {}", self.token))
.json(&request)
.send()
.await
.map_err(|e| SyncError::NetworkError(e.to_string()))?;
if response.status().is_client_error() {
return Err(SyncError::AuthError("Invalid or missing token".to_string()));
}
response
.json()
.await
.map_err(|e| SyncError::SerializationError(e.to_string()))
}
pub async fn presign_download_batch(
&self,
keys: Vec<String>,
) -> SyncResult<PresignDownloadBatchResponse> {
let request = PresignDownloadBatchRequest {
keys,
expires_in: Some(3600),
};
let response = self
.client
.post(self.url("presign-download-batch"))
.header("Authorization", format!("Bearer {}", self.token))
.json(&request)
.send()
.await
.map_err(|e| SyncError::NetworkError(e.to_string()))?;
if response.status().is_client_error() {
return Err(SyncError::AuthError("Invalid or missing token".to_string()));
}
response
.json()
.await
.map_err(|e| SyncError::SerializationError(e.to_string()))
}
pub async fn delete_prefix(
&self,
prefix: &str,
tombstone_key: Option<&str>,
) -> SyncResult<DeletePrefixResponse> {
let response = self
.client
.post(self.url("delete-prefix"))
.header("Authorization", format!("Bearer {}", self.token))
.json(&DeletePrefixRequest {
prefix: prefix.to_string(),
tombstone_key: tombstone_key.map(|s| s.to_string()),
deleted_at: Some(chrono::Utc::now().to_rfc3339()),
})
.send()
.await
.map_err(|e| SyncError::NetworkError(e.to_string()))?;
if response.status().is_client_error() {
return Err(SyncError::AuthError("Invalid or missing token".to_string()));
}
response
.json()
.await
.map_err(|e| SyncError::SerializationError(e.to_string()))
}
}
src-tauri/src/sync/engine.rs
+1368
View File
File diff suppressed because it is too large Load Diff
src-tauri/src/sync/manifest.rs
+636
View File
@@ -0,0 +1,636 @@
use chrono::{DateTime, Utc};
use globset::{Glob, GlobSet, GlobSetBuilder};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::fs::{self, File};
use std::io::{BufReader, Read};
use std::path::Path;
use std::time::SystemTime;
use super::types::{SyncError, SyncResult};
/// Default exclude patterns for volatile Chromium profile files
pub const DEFAULT_EXCLUDE_PATTERNS: &[&str] = &[
"Cache/**",
"Code Cache/**",
"GPUCache/**",
"GrShaderCache/**",
"ShaderCache/**",
"Service Worker/CacheStorage/**",
"Crashpad/**",
"Crash Reports/**",
"BrowserMetrics/**",
"blob_storage/**",
"*.log",
"*.tmp",
"LOG",
"LOG.old",
"LOCK",
".donut-sync/**",
];
/// A single file entry in the manifest
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ManifestFileEntry {
pub path: String,
pub size: u64,
pub mtime: i64,
pub hash: String,
}
/// The sync manifest for a profile
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SyncManifest {
pub version: u32,
#[serde(rename = "profileId")]
pub profile_id: String,
#[serde(rename = "generatedAt")]
pub generated_at: String,
#[serde(rename = "updatedAt")]
pub updated_at: String,
#[serde(rename = "excludeGlobs")]
pub exclude_globs: Vec<String>,
pub files: Vec<ManifestFileEntry>,
}
impl SyncManifest {
pub fn new(profile_id: String, exclude_globs: Vec<String>) -> Self {
let now = Utc::now().to_rfc3339();
Self {
version: 1,
profile_id,
generated_at: now.clone(),
updated_at: now,
exclude_globs,
files: Vec::new(),
}
}
pub fn updated_at_datetime(&self) -> Option<DateTime<Utc>> {
DateTime::parse_from_rfc3339(&self.updated_at)
.ok()
.map(|dt| dt.with_timezone(&Utc))
}
}
/// Local hash cache to avoid re-hashing unchanged files
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct HashCache {
pub entries: HashMap<String, HashCacheEntry>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HashCacheEntry {
pub size: u64,
pub mtime: i64,
pub hash: String,
}
impl HashCache {
pub fn load(cache_path: &Path) -> Self {
if !cache_path.exists() {
return Self::default();
}
match fs::read_to_string(cache_path) {
Ok(content) => serde_json::from_str(&content).unwrap_or_default(),
Err(_) => Self::default(),
}
}
pub fn save(&self, cache_path: &Path) -> SyncResult<()> {
if let Some(parent) = cache_path.parent() {
fs::create_dir_all(parent).map_err(|e| {
SyncError::IoError(format!(
"Failed to create cache directory {}: {e}",
parent.display()
))
})?;
}
let json = serde_json::to_string_pretty(self)
.map_err(|e| SyncError::SerializationError(format!("Failed to serialize hash cache: {e}")))?;
fs::write(cache_path, json).map_err(|e| {
SyncError::IoError(format!(
"Failed to write hash cache {}: {e}",
cache_path.display()
))
})?;
Ok(())
}
pub fn get(&self, path: &str, size: u64, mtime: i64) -> Option<&str> {
self.entries.get(path).and_then(|entry| {
if entry.size == size && entry.mtime == mtime {
Some(entry.hash.as_str())
} else {
None
}
})
}
pub fn insert(&mut self, path: String, size: u64, mtime: i64, hash: String) {
self
.entries
.insert(path, HashCacheEntry { size, mtime, hash });
}
}
/// Build a GlobSet from exclude patterns
fn build_exclude_globset(patterns: &[String]) -> SyncResult<GlobSet> {
let mut builder = GlobSetBuilder::new();
for pattern in patterns {
let glob = Glob::new(pattern)
.map_err(|e| SyncError::InvalidData(format!("Invalid exclude pattern '{}': {e}", pattern)))?;
builder.add(glob);
}
builder
.build()
.map_err(|e| SyncError::InvalidData(format!("Failed to build exclude globset: {e}")))
}
/// Compute blake3 hash of a file
/// Returns None if the file doesn't exist (was deleted)
fn hash_file(path: &Path) -> Result<Option<String>, SyncError> {
let file = match File::open(path) {
Ok(f) => f,
Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(None),
Err(e) => {
return Err(SyncError::IoError(format!(
"Failed to open {}: {e}",
path.display()
)));
}
};
let mut reader = BufReader::new(file);
let mut hasher = blake3::Hasher::new();
let mut buffer = [0u8; 65536]; // 64KB buffer
loop {
let bytes_read = reader
.read(&mut buffer)
.map_err(|e| SyncError::IoError(format!("Failed to read {}: {e}", path.display())))?;
if bytes_read == 0 {
break;
}
hasher.update(&buffer[..bytes_read]);
}
Ok(Some(hasher.finalize().to_hex().to_string()))
}
/// Get mtime as unix timestamp
/// Returns None if the file doesn't exist (was deleted)
fn get_mtime(path: &Path) -> Result<Option<i64>, SyncError> {
let metadata = match path.metadata() {
Ok(m) => m,
Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(None),
Err(e) => {
return Err(SyncError::IoError(format!(
"Failed to get metadata for {}: {e}",
path.display()
)));
}
};
let mtime = metadata
.modified()
.map_err(|e| SyncError::IoError(format!("Failed to get mtime for {}: {e}", path.display())))?;
Ok(Some(
mtime
.duration_since(SystemTime::UNIX_EPOCH)
.map(|d| d.as_secs() as i64)
.unwrap_or(0),
))
}
/// Generate a manifest for a profile directory
pub fn generate_manifest(
profile_id: &str,
profile_dir: &Path,
cache: &mut HashCache,
) -> SyncResult<SyncManifest> {
let exclude_patterns: Vec<String> = DEFAULT_EXCLUDE_PATTERNS
.iter()
.map(|s| s.to_string())
.collect();
let globset = build_exclude_globset(&exclude_patterns)?;
let mut manifest = SyncManifest::new(profile_id.to_string(), exclude_patterns);
let mut max_mtime: i64 = 0;
if !profile_dir.exists() {
log::debug!(
"Profile directory doesn't exist: {}, creating empty manifest",
profile_dir.display()
);
return Ok(manifest);
}
fn walk_dir(
dir: &Path,
base_dir: &Path,
globset: &GlobSet,
cache: &mut HashCache,
files: &mut Vec<ManifestFileEntry>,
max_mtime: &mut i64,
) -> SyncResult<()> {
let entries = fs::read_dir(dir).map_err(|e| {
SyncError::IoError(format!("Failed to read directory {}: {e}", dir.display()))
})?;
for entry in entries {
let entry = entry.map_err(|e| {
SyncError::IoError(format!("Failed to read entry in {}: {e}", dir.display()))
})?;
let path = entry.path();
let relative_path = path
.strip_prefix(base_dir)
.map_err(|_| SyncError::IoError("Failed to compute relative path".to_string()))?
.to_string_lossy()
.replace('\\', "/");
// Check if excluded
if globset.is_match(&relative_path) {
continue;
}
// Get metadata - skip if file was deleted between directory read and metadata access
let metadata = match path.metadata() {
Ok(m) => m,
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
log::debug!(
"File disappeared during manifest generation, skipping: {}",
path.display()
);
continue;
}
Err(e) => {
return Err(SyncError::IoError(format!(
"Failed to get metadata for {}: {e}",
path.display()
)));
}
};
if metadata.is_dir() {
walk_dir(&path, base_dir, globset, cache, files, max_mtime)?;
} else if metadata.is_file() {
let size = metadata.len();
let mtime = match get_mtime(&path)? {
Some(m) => m,
None => {
// File was deleted, skip it
log::debug!(
"File disappeared during manifest generation, skipping: {}",
path.display()
);
continue;
}
};
*max_mtime = (*max_mtime).max(mtime);
// Check cache for existing hash
let hash = if let Some(cached_hash) = cache.get(&relative_path, size, mtime) {
cached_hash.to_string()
} else {
match hash_file(&path)? {
Some(computed_hash) => {
cache.insert(relative_path.clone(), size, mtime, computed_hash.clone());
computed_hash
}
None => {
// File was deleted, skip it
log::debug!(
"File disappeared during manifest generation, skipping: {}",
path.display()
);
continue;
}
}
};
files.push(ManifestFileEntry {
path: relative_path,
size,
mtime,
hash,
});
}
}
Ok(())
}
walk_dir(
profile_dir,
profile_dir,
&globset,
cache,
&mut manifest.files,
&mut max_mtime,
)?;
// Sort files for deterministic manifest
manifest.files.sort_by(|a, b| a.path.cmp(&b.path));
// Update the updatedAt timestamp to max mtime
if max_mtime > 0 {
if let Some(dt) = DateTime::from_timestamp(max_mtime, 0) {
manifest.updated_at = dt.to_rfc3339();
}
}
Ok(manifest)
}
/// Compute the diff between local and remote manifests
#[derive(Debug, Default)]
pub struct ManifestDiff {
pub files_to_upload: Vec<ManifestFileEntry>,
pub files_to_download: Vec<ManifestFileEntry>,
pub files_to_delete_local: Vec<String>,
pub files_to_delete_remote: Vec<String>,
}
impl ManifestDiff {
pub fn is_empty(&self) -> bool {
self.files_to_upload.is_empty()
&& self.files_to_download.is_empty()
&& self.files_to_delete_local.is_empty()
&& self.files_to_delete_remote.is_empty()
}
}
/// Compute what needs to be synced between local and remote
pub fn compute_diff(local: &SyncManifest, remote: Option<&SyncManifest>) -> ManifestDiff {
let mut diff = ManifestDiff::default();
let Some(remote) = remote else {
// No remote manifest - upload everything
diff.files_to_upload = local.files.clone();
return diff;
};
// Build hash maps for quick lookup
let local_files: HashMap<&str, &ManifestFileEntry> =
local.files.iter().map(|f| (f.path.as_str(), f)).collect();
let remote_files: HashMap<&str, &ManifestFileEntry> =
remote.files.iter().map(|f| (f.path.as_str(), f)).collect();
// Compare timestamps to determine direction
let local_updated = local.updated_at_datetime();
let remote_updated = remote.updated_at_datetime();
let local_is_newer = match (local_updated, remote_updated) {
(Some(l), Some(r)) => l > r,
(Some(_), None) => true,
(None, Some(_)) => false,
(None, None) => true, // Default to uploading
};
if local_is_newer {
// Upload changed/new files, delete remote files that don't exist locally
for (path, local_entry) in &local_files {
match remote_files.get(path) {
Some(remote_entry) if remote_entry.hash != local_entry.hash => {
diff.files_to_upload.push((*local_entry).clone());
}
None => {
diff.files_to_upload.push((*local_entry).clone());
}
_ => {}
}
}
for path in remote_files.keys() {
if !local_files.contains_key(path) {
diff.files_to_delete_remote.push(path.to_string());
}
}
} else {
// Download changed/new files, delete local files that don't exist remotely
for (path, remote_entry) in &remote_files {
match local_files.get(path) {
Some(local_entry) if local_entry.hash != remote_entry.hash => {
diff.files_to_download.push((*remote_entry).clone());
}
None => {
diff.files_to_download.push((*remote_entry).clone());
}
_ => {}
}
}
for path in local_files.keys() {
if !remote_files.contains_key(path) {
diff.files_to_delete_local.push(path.to_string());
}
}
}
diff
}
/// Get the path to the hash cache file for a profile
pub fn get_cache_path(profile_dir: &Path) -> std::path::PathBuf {
profile_dir.join(".donut-sync").join("cache.json")
}
#[cfg(test)]
mod tests {
use super::*;
use tempfile::TempDir;
#[test]
fn test_hash_cache_operations() {
let cache_dir = TempDir::new().unwrap();
let cache_path = cache_dir.path().join("cache.json");
let mut cache = HashCache::default();
cache.insert(
"test.txt".to_string(),
100,
1234567890,
"abc123".to_string(),
);
assert_eq!(cache.get("test.txt", 100, 1234567890), Some("abc123"));
assert_eq!(cache.get("test.txt", 100, 999), None); // Different mtime
assert_eq!(cache.get("test.txt", 50, 1234567890), None); // Different size
cache.save(&cache_path).unwrap();
let loaded = HashCache::load(&cache_path);
assert_eq!(loaded.get("test.txt", 100, 1234567890), Some("abc123"));
}
#[test]
fn test_generate_manifest_empty_dir() {
let temp_dir = TempDir::new().unwrap();
let profile_dir = temp_dir.path().join("profile");
fs::create_dir_all(&profile_dir).unwrap();
let mut cache = HashCache::default();
let manifest = generate_manifest("test-profile", &profile_dir, &mut cache).unwrap();
assert_eq!(manifest.profile_id, "test-profile");
assert_eq!(manifest.version, 1);
assert!(manifest.files.is_empty());
}
#[test]
fn test_generate_manifest_with_files() {
let temp_dir = TempDir::new().unwrap();
let profile_dir = temp_dir.path().join("profile");
fs::create_dir_all(&profile_dir).unwrap();
fs::write(profile_dir.join("file1.txt"), "hello").unwrap();
fs::write(profile_dir.join("file2.txt"), "world").unwrap();
fs::create_dir_all(profile_dir.join("subdir")).unwrap();
fs::write(profile_dir.join("subdir/file3.txt"), "nested").unwrap();
let mut cache = HashCache::default();
let manifest = generate_manifest("test-profile", &profile_dir, &mut cache).unwrap();
assert_eq!(manifest.files.len(), 3);
assert!(manifest.files.iter().any(|f| f.path == "file1.txt"));
assert!(manifest.files.iter().any(|f| f.path == "file2.txt"));
assert!(manifest.files.iter().any(|f| f.path == "subdir/file3.txt"));
}
#[test]
fn test_generate_manifest_excludes_cache() {
let temp_dir = TempDir::new().unwrap();
let profile_dir = temp_dir.path().join("profile");
fs::create_dir_all(&profile_dir).unwrap();
fs::write(profile_dir.join("file1.txt"), "keep").unwrap();
fs::create_dir_all(profile_dir.join("Cache")).unwrap();
fs::write(profile_dir.join("Cache/data"), "exclude").unwrap();
fs::create_dir_all(profile_dir.join("Code Cache")).unwrap();
fs::write(profile_dir.join("Code Cache/wasm"), "exclude").unwrap();
let mut cache = HashCache::default();
let manifest = generate_manifest("test-profile", &profile_dir, &mut cache).unwrap();
assert_eq!(manifest.files.len(), 1);
assert_eq!(manifest.files[0].path, "file1.txt");
}
#[test]
fn test_compute_diff_upload_all_when_no_remote() {
let local = SyncManifest {
version: 1,
profile_id: "test".to_string(),
generated_at: Utc::now().to_rfc3339(),
updated_at: Utc::now().to_rfc3339(),
exclude_globs: vec![],
files: vec![
ManifestFileEntry {
path: "file1.txt".to_string(),
size: 10,
mtime: 1000,
hash: "abc".to_string(),
},
ManifestFileEntry {
path: "file2.txt".to_string(),
size: 20,
mtime: 2000,
hash: "def".to_string(),
},
],
};
let diff = compute_diff(&local, None);
assert_eq!(diff.files_to_upload.len(), 2);
assert!(diff.files_to_download.is_empty());
assert!(diff.files_to_delete_local.is_empty());
assert!(diff.files_to_delete_remote.is_empty());
}
#[test]
fn test_compute_diff_detect_changes() {
let old_time = "2024-01-01T00:00:00Z";
let new_time = "2024-01-02T00:00:00Z";
let local = SyncManifest {
version: 1,
profile_id: "test".to_string(),
generated_at: new_time.to_string(),
updated_at: new_time.to_string(),
exclude_globs: vec![],
files: vec![
ManifestFileEntry {
path: "unchanged.txt".to_string(),
size: 10,
mtime: 1000,
hash: "same".to_string(),
},
ManifestFileEntry {
path: "changed.txt".to_string(),
size: 10,
mtime: 2000,
hash: "new_hash".to_string(),
},
ManifestFileEntry {
path: "new_file.txt".to_string(),
size: 5,
mtime: 3000,
hash: "new".to_string(),
},
],
};
let remote = SyncManifest {
version: 1,
profile_id: "test".to_string(),
generated_at: old_time.to_string(),
updated_at: old_time.to_string(),
exclude_globs: vec![],
files: vec![
ManifestFileEntry {
path: "unchanged.txt".to_string(),
size: 10,
mtime: 1000,
hash: "same".to_string(),
},
ManifestFileEntry {
path: "changed.txt".to_string(),
size: 10,
mtime: 1000,
hash: "old_hash".to_string(),
},
ManifestFileEntry {
path: "deleted.txt".to_string(),
size: 8,
mtime: 500,
hash: "gone".to_string(),
},
],
};
let diff = compute_diff(&local, Some(&remote));
// Local is newer, so we upload changed/new and delete remote-only
assert_eq!(diff.files_to_upload.len(), 2); // changed + new
assert!(diff.files_to_upload.iter().any(|f| f.path == "changed.txt"));
assert!(diff
.files_to_upload
.iter()
.any(|f| f.path == "new_file.txt"));
assert!(diff.files_to_download.is_empty());
assert!(diff.files_to_delete_local.is_empty());
assert_eq!(diff.files_to_delete_remote.len(), 1);
assert!(diff
.files_to_delete_remote
.contains(&"deleted.txt".to_string()));
}
}
src-tauri/src/sync/mod.rs
+19
View File
@@ -0,0 +1,19 @@
mod client;
mod engine;
pub mod manifest;
pub mod scheduler;
pub mod subscription;
pub mod types;
pub use client::SyncClient;
pub use engine::{
enable_group_sync_if_needed, enable_proxy_sync_if_needed, is_group_in_use_by_synced_profile,
is_group_used_by_synced_profile, is_proxy_in_use_by_synced_profile,
is_proxy_used_by_synced_profile, request_profile_sync, set_group_sync_enabled,
set_profile_sync_enabled, set_proxy_sync_enabled, sync_profile, trigger_sync_for_profile,
SyncEngine,
};
pub use manifest::{compute_diff, generate_manifest, HashCache, ManifestDiff, SyncManifest};
pub use scheduler::{get_global_scheduler, set_global_scheduler, SyncScheduler};
pub use subscription::{SubscriptionManager, SyncWorkItem};
pub use types::{SyncError, SyncResult};
src-tauri/src/sync/scheduler.rs
+613
View File
@@ -0,0 +1,613 @@
use super::engine::SyncEngine;
use super::subscription::SyncWorkItem;
use crate::profile::ProfileManager;
use once_cell::sync::OnceCell;
use std::collections::{HashMap, HashSet};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use std::time::{Duration, Instant};
use tauri::Emitter;
use tokio::sync::mpsc;
use tokio::sync::Mutex;
use tokio::time::sleep;
static GLOBAL_SCHEDULER: OnceCell<Arc<SyncScheduler>> = OnceCell::new();
pub fn get_global_scheduler() -> Option<Arc<SyncScheduler>> {
GLOBAL_SCHEDULER.get().cloned()
}
pub fn set_global_scheduler(scheduler: Arc<SyncScheduler>) {
let _ = GLOBAL_SCHEDULER.set(scheduler);
}
#[derive(Debug, Clone)]
struct ProfileStopTime {
#[allow(dead_code)]
stopped_at: Instant,
queued: bool,
}
pub struct SyncScheduler {
running: Arc<AtomicBool>,
pending_profiles: Arc<Mutex<HashMap<String, ProfileStopTime>>>,
pending_proxies: Arc<Mutex<HashSet<String>>>,
pending_groups: Arc<Mutex<HashSet<String>>>,
pending_tombstones: Arc<Mutex<Vec<(String, String)>>>,
running_profiles: Arc<Mutex<HashSet<String>>>,
in_flight_profiles: Arc<Mutex<HashSet<String>>>,
}
impl Default for SyncScheduler {
fn default() -> Self {
Self::new()
}
}
impl SyncScheduler {
pub fn new() -> Self {
Self {
running: Arc::new(AtomicBool::new(false)),
pending_profiles: Arc::new(Mutex::new(HashMap::new())),
pending_proxies: Arc::new(Mutex::new(HashSet::new())),
pending_groups: Arc::new(Mutex::new(HashSet::new())),
pending_tombstones: Arc::new(Mutex::new(Vec::new())),
running_profiles: Arc::new(Mutex::new(HashSet::new())),
in_flight_profiles: Arc::new(Mutex::new(HashSet::new())),
}
}
pub fn is_running(&self) -> bool {
self.running.load(Ordering::SeqCst)
}
pub fn stop(&self) {
self.running.store(false, Ordering::SeqCst);
}
/// Check if any sync operation is currently in progress
pub async fn is_sync_in_progress(&self) -> bool {
let in_flight = self.in_flight_profiles.lock().await;
if !in_flight.is_empty() {
return true;
}
drop(in_flight);
let pending_profiles = self.pending_profiles.lock().await;
if !pending_profiles.is_empty() {
return true;
}
drop(pending_profiles);
let pending_proxies = self.pending_proxies.lock().await;
if !pending_proxies.is_empty() {
return true;
}
drop(pending_proxies);
let pending_groups = self.pending_groups.lock().await;
if !pending_groups.is_empty() {
return true;
}
drop(pending_groups);
let pending_tombstones = self.pending_tombstones.lock().await;
if !pending_tombstones.is_empty() {
return true;
}
false
}
pub async fn mark_profile_running(&self, profile_id: &str) {
let mut running = self.running_profiles.lock().await;
running.insert(profile_id.to_string());
log::debug!("Marked profile {} as running", profile_id);
}
pub async fn mark_profile_stopped(&self, profile_id: &str) {
let mut running = self.running_profiles.lock().await;
running.remove(profile_id);
log::debug!("Marked profile {} as stopped", profile_id);
let mut pending = self.pending_profiles.lock().await;
if pending.contains_key(profile_id) {
// Set stopped_at to past so it syncs immediately
pending.insert(
profile_id.to_string(),
ProfileStopTime {
stopped_at: Instant::now() - Duration::from_secs(3),
queued: true,
},
);
log::debug!(
"Profile {} has pending sync, will execute immediately",
profile_id
);
}
}
pub async fn is_profile_running(&self, profile_id: &str) -> bool {
// First check our internal tracking
let running = self.running_profiles.lock().await;
if running.contains(profile_id) {
return true;
}
drop(running);
// Also check the actual profile state from ProfileManager
let profile_manager = ProfileManager::instance();
if let Ok(profiles) = profile_manager.list_profiles() {
if let Some(profile) = profiles.iter().find(|p| p.id.to_string() == profile_id) {
return profile.process_id.is_some();
}
}
false
}
pub async fn queue_profile_sync(&self, profile_id: String) {
self.queue_profile_sync_internal(profile_id).await;
}
pub async fn queue_profile_sync_immediate(&self, profile_id: String) {
self.queue_profile_sync_internal(profile_id).await;
}
async fn queue_profile_sync_internal(&self, profile_id: String) {
let is_running = self.is_profile_running(&profile_id).await;
let mut pending = self.pending_profiles.lock().await;
if is_running {
// Profile is running - queue for after it stops
pending.insert(
profile_id.clone(),
ProfileStopTime {
stopped_at: Instant::now(),
queued: true,
},
);
log::debug!(
"Profile {} is running, queued sync for after stop",
profile_id
);
} else {
// Profile is not running - sync immediately (set stopped_at to past)
pending.insert(
profile_id.clone(),
ProfileStopTime {
stopped_at: Instant::now() - Duration::from_secs(3),
queued: true,
},
);
log::debug!("Profile {} queued for immediate sync", profile_id);
}
}
pub async fn queue_proxy_sync(&self, proxy_id: String) {
let mut pending = self.pending_proxies.lock().await;
pending.insert(proxy_id);
}
pub async fn queue_group_sync(&self, group_id: String) {
let mut pending = self.pending_groups.lock().await;
pending.insert(group_id);
}
pub async fn queue_tombstone(&self, entity_type: String, entity_id: String) {
let mut pending = self.pending_tombstones.lock().await;
if !pending
.iter()
.any(|(t, i)| t == &entity_type && i == &entity_id)
{
pending.push((entity_type, entity_id));
}
}
pub async fn sync_all_enabled_profiles(&self, app_handle: &tauri::AppHandle) {
log::info!("Starting initial sync for all enabled profiles...");
let profiles = {
let profile_manager = ProfileManager::instance();
match profile_manager.list_profiles() {
Ok(p) => p,
Err(e) => {
log::error!("Failed to list profiles for initial sync: {e}");
return;
}
}
};
let sync_enabled_profiles: Vec<_> = profiles.into_iter().filter(|p| p.sync_enabled).collect();
if sync_enabled_profiles.is_empty() {
log::debug!("No sync-enabled profiles found");
return;
}
log::info!(
"Found {} sync-enabled profiles, queueing for sync",
sync_enabled_profiles.len()
);
for profile in sync_enabled_profiles {
let profile_id = profile.id.to_string();
let is_running = profile.process_id.is_some();
// Emit initial status
let _ = app_handle.emit(
"profile-sync-status",
serde_json::json!({
"profile_id": profile_id,
"status": if is_running { "waiting" } else { "syncing" }
}),
);
// Queue for immediate sync (or wait if running)
self.queue_profile_sync_immediate(profile_id).await;
}
}
pub async fn start(
self: Arc<Self>,
app_handle: tauri::AppHandle,
mut work_rx: mpsc::UnboundedReceiver<SyncWorkItem>,
) {
if self.running.swap(true, Ordering::SeqCst) {
return;
}
let scheduler = self.clone();
let app_handle_clone = app_handle.clone();
tokio::spawn(async move {
while scheduler.running.load(Ordering::SeqCst) {
tokio::select! {
Some(work_item) = work_rx.recv() => {
match work_item {
SyncWorkItem::Profile(id) => scheduler.queue_profile_sync(id).await,
SyncWorkItem::Proxy(id) => scheduler.queue_proxy_sync(id).await,
SyncWorkItem::Group(id) => scheduler.queue_group_sync(id).await,
SyncWorkItem::Tombstone(entity_type, entity_id) => {
scheduler.queue_tombstone(entity_type, entity_id).await
}
}
}
_ = sleep(Duration::from_millis(500)) => {
scheduler.process_pending(&app_handle_clone).await;
}
}
}
log::info!("Sync scheduler stopped");
});
}
async fn process_pending(&self, app_handle: &tauri::AppHandle) {
self.process_pending_profiles(app_handle).await;
self.process_pending_proxies(app_handle).await;
self.process_pending_groups(app_handle).await;
self.process_pending_tombstones(app_handle).await;
}
async fn process_pending_profiles(&self, app_handle: &tauri::AppHandle) {
let profiles_to_sync: Vec<String> = {
let mut pending = self.pending_profiles.lock().await;
let running = self.running_profiles.lock().await;
let in_flight = self.in_flight_profiles.lock().await;
// Sync immediately if not running and not in-flight (no delay check)
let ready: Vec<String> = pending
.iter()
.filter(|(id, stop_time)| {
!running.contains(*id) && !in_flight.contains(*id) && stop_time.queued
})
.map(|(id, _)| id.clone())
.collect();
for id in &ready {
pending.remove(id);
}
ready
};
for profile_id in profiles_to_sync {
// Mark as in-flight to prevent duplicate syncs
{
let mut in_flight = self.in_flight_profiles.lock().await;
if in_flight.contains(&profile_id) {
log::debug!("Profile {} already in-flight, skipping", profile_id);
continue;
}
in_flight.insert(profile_id.clone());
}
log::info!("Executing queued sync for profile {}", profile_id);
let _ = app_handle.emit(
"profile-sync-status",
serde_json::json!({
"profile_id": profile_id,
"status": "syncing"
}),
);
let profile_to_sync = {
let profile_manager = ProfileManager::instance();
profile_manager.list_profiles().ok().and_then(|profiles| {
profiles
.into_iter()
.find(|p| p.id.to_string() == profile_id && p.sync_enabled)
})
};
let Some(profile) = profile_to_sync else {
// Remove from in-flight
let mut in_flight = self.in_flight_profiles.lock().await;
in_flight.remove(&profile_id);
continue;
};
let result = match SyncEngine::create_from_settings(app_handle).await {
Ok(engine) => engine.sync_profile(app_handle, &profile).await,
Err(e) => {
log::error!("Failed to create sync engine: {}", e);
Err(super::types::SyncError::NotConfigured)
}
};
// Remove from in-flight and check if sync just completed
let sync_just_completed = {
let mut in_flight = self.in_flight_profiles.lock().await;
in_flight.remove(&profile_id);
// If this was the last in-flight profile and there are no pending profiles, sync just completed
in_flight.is_empty()
&& self.pending_profiles.lock().await.is_empty()
&& self.pending_proxies.lock().await.is_empty()
&& self.pending_groups.lock().await.is_empty()
};
match result {
Ok(()) => {
log::info!("Profile {} synced successfully", profile_id);
let _ = app_handle.emit(
"profile-sync-status",
serde_json::json!({
"profile_id": profile_id,
"status": "synced"
}),
);
}
Err(e) => {
log::error!("Failed to sync profile {}: {}", profile_id, e);
let _ = app_handle.emit(
"profile-sync-status",
serde_json::json!({
"profile_id": profile_id,
"status": "error",
"error": e.to_string()
}),
);
}
}
// Trigger cleanup after sync completes if this was the last profile
if sync_just_completed {
log::debug!("All profile syncs completed, triggering cleanup");
let registry = crate::downloaded_browsers_registry::DownloadedBrowsersRegistry::instance();
if let Err(e) = registry.cleanup_unused_binaries() {
log::warn!("Cleanup after sync failed: {e}");
} else {
log::debug!("Cleanup after sync completed successfully");
}
}
}
}
async fn process_pending_proxies(&self, app_handle: &tauri::AppHandle) {
let proxies_to_sync: Vec<String> = {
let mut pending = self.pending_proxies.lock().await;
let list: Vec<String> = pending.drain().collect();
list
};
if proxies_to_sync.is_empty() {
return;
}
match SyncEngine::create_from_settings(app_handle).await {
Ok(engine) => {
for proxy_id in proxies_to_sync {
log::info!("Syncing proxy {}", proxy_id);
let _ = app_handle.emit(
"proxy-sync-status",
serde_json::json!({
"id": proxy_id,
"status": "syncing"
}),
);
match engine
.sync_proxy_by_id_with_handle(&proxy_id, app_handle)
.await
{
Ok(()) => {
let _ = app_handle.emit(
"proxy-sync-status",
serde_json::json!({
"id": proxy_id,
"status": "synced"
}),
);
}
Err(e) => {
log::error!("Failed to sync proxy {}: {}", proxy_id, e);
let _ = app_handle.emit(
"proxy-sync-status",
serde_json::json!({
"id": proxy_id,
"status": "error"
}),
);
}
}
}
// Check if all sync work is complete after proxies finish
if !self.is_sync_in_progress().await {
log::debug!("All syncs completed after proxy sync, triggering cleanup");
let registry =
crate::downloaded_browsers_registry::DownloadedBrowsersRegistry::instance();
if let Err(e) = registry.cleanup_unused_binaries() {
log::warn!("Cleanup after sync failed: {e}");
} else {
log::debug!("Cleanup after sync completed successfully");
}
}
}
Err(e) => {
log::error!("Failed to create sync engine: {}", e);
}
}
}
async fn process_pending_groups(&self, app_handle: &tauri::AppHandle) {
let groups_to_sync: Vec<String> = {
let mut pending = self.pending_groups.lock().await;
let list: Vec<String> = pending.drain().collect();
list
};
if groups_to_sync.is_empty() {
return;
}
match SyncEngine::create_from_settings(app_handle).await {
Ok(engine) => {
for group_id in groups_to_sync {
log::info!("Syncing group {}", group_id);
let _ = app_handle.emit(
"group-sync-status",
serde_json::json!({
"id": group_id,
"status": "syncing"
}),
);
match engine
.sync_group_by_id_with_handle(&group_id, app_handle)
.await
{
Ok(()) => {
let _ = app_handle.emit(
"group-sync-status",
serde_json::json!({
"id": group_id,
"status": "synced"
}),
);
}
Err(e) => {
log::error!("Failed to sync group {}: {}", group_id, e);
let _ = app_handle.emit(
"group-sync-status",
serde_json::json!({
"id": group_id,
"status": "error"
}),
);
}
}
}
// Check if all sync work is complete after groups finish
if !self.is_sync_in_progress().await {
log::debug!("All syncs completed after group sync, triggering cleanup");
let registry =
crate::downloaded_browsers_registry::DownloadedBrowsersRegistry::instance();
if let Err(e) = registry.cleanup_unused_binaries() {
log::warn!("Cleanup after sync failed: {e}");
} else {
log::debug!("Cleanup after sync completed successfully");
}
}
}
Err(e) => {
log::error!("Failed to create sync engine: {}", e);
}
}
}
async fn process_pending_tombstones(&self, app_handle: &tauri::AppHandle) {
let tombstones: Vec<(String, String)> = {
let mut pending = self.pending_tombstones.lock().await;
std::mem::take(&mut *pending)
};
if tombstones.is_empty() {
return;
}
for (entity_type, entity_id) in tombstones {
log::info!("Processing tombstone for {} {}", entity_type, entity_id);
match entity_type.as_str() {
"profile" => {
let exists_locally = {
let profile_manager = ProfileManager::instance();
if let Ok(profiles) = profile_manager.list_profiles() {
let profile_uuid = uuid::Uuid::parse_str(&entity_id).ok();
profile_uuid
.as_ref()
.map(|uuid| profiles.iter().any(|p| p.id == *uuid))
.unwrap_or(false)
} else {
false
}
};
if exists_locally {
// Profile exists locally but was deleted remotely - delete locally
log::info!(
"Profile {} exists locally, deleting due to remote tombstone",
entity_id
);
// Note: We don't actually delete here to avoid data loss.
// The user should be notified or we could add a confirmation step.
// For now, just log it.
} else {
// Profile doesn't exist locally - check if it still exists remotely
// (tombstone might have been created but profile files still exist)
// Try to download it
match SyncEngine::create_from_settings(app_handle).await {
Ok(engine) => {
if let Ok(true) = engine
.download_profile_if_missing(app_handle, &entity_id)
.await
{
log::info!(
"Downloaded missing profile {} from remote storage",
entity_id
);
}
}
Err(e) => {
log::debug!("Sync not configured, skipping profile download: {}", e);
}
}
}
}
"proxy" => {
log::debug!(
"Proxy tombstone for {} - local deletion not implemented",
entity_id
);
}
"group" => {
log::debug!(
"Group tombstone for {} - local deletion not implemented",
entity_id
);
}
_ => {}
}
}
}
}
src-tauri/src/sync/subscription.rs
+310
View File
@@ -0,0 +1,310 @@
use crate::settings_manager::SettingsManager;
use reqwest::Client;
use serde::Deserialize;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use std::time::Duration;
use tauri::Emitter;
use tokio::sync::mpsc;
use tokio::time::sleep;
#[derive(Debug, Clone, Deserialize)]
pub struct SubscribeEvent {
#[serde(rename = "type")]
pub event_type: String,
pub key: Option<String>,
#[serde(rename = "lastModified")]
pub last_modified: Option<String>,
pub size: Option<u64>,
}
#[derive(Debug, Clone)]
pub enum SyncWorkItem {
Profile(String),
Proxy(String),
Group(String),
Tombstone(String, String),
}
pub struct SyncSubscription {
client: Client,
base_url: String,
token: String,
running: Arc<AtomicBool>,
work_tx: mpsc::UnboundedSender<SyncWorkItem>,
}
impl SyncSubscription {
pub fn new(
base_url: String,
token: String,
work_tx: mpsc::UnboundedSender<SyncWorkItem>,
) -> Self {
Self {
client: Client::new(),
base_url: base_url.trim_end_matches('/').to_string(),
token,
running: Arc::new(AtomicBool::new(false)),
work_tx,
}
}
pub async fn create_from_settings(
app_handle: &tauri::AppHandle,
work_tx: mpsc::UnboundedSender<SyncWorkItem>,
) -> Result<Option<Self>, String> {
let manager = SettingsManager::instance();
let settings = manager
.load_settings()
.map_err(|e| format!("Failed to load settings: {e}"))?;
let Some(server_url) = settings.sync_server_url else {
return Ok(None);
};
let token = manager
.get_sync_token(app_handle)
.await
.map_err(|e| format!("Failed to get sync token: {e}"))?;
let Some(token) = token else {
return Ok(None);
};
Ok(Some(Self::new(server_url, token, work_tx)))
}
pub fn is_running(&self) -> bool {
self.running.load(Ordering::SeqCst)
}
pub fn stop(&self) {
self.running.store(false, Ordering::SeqCst);
}
pub async fn start(&self, app_handle: tauri::AppHandle) {
if self.running.swap(true, Ordering::SeqCst) {
return;
}
let running = self.running.clone();
let base_url = self.base_url.clone();
let token = self.token.clone();
let work_tx = self.work_tx.clone();
let client = self.client.clone();
tokio::spawn(async move {
while running.load(Ordering::SeqCst) {
match Self::connect_and_listen(&client, &base_url, &token, &work_tx, &running, &app_handle)
.await
{
Ok(()) => {
log::info!("SSE connection closed gracefully");
}
Err(e) => {
log::warn!("SSE connection error: {e}, reconnecting in 5s");
sleep(Duration::from_secs(5)).await;
}
}
if running.load(Ordering::SeqCst) {
sleep(Duration::from_secs(1)).await;
}
}
log::info!("Sync subscription stopped");
});
}
async fn connect_and_listen(
client: &Client,
base_url: &str,
token: &str,
work_tx: &mpsc::UnboundedSender<SyncWorkItem>,
running: &Arc<AtomicBool>,
app_handle: &tauri::AppHandle,
) -> Result<(), String> {
let url = format!("{base_url}/v1/objects/subscribe");
let response = client
.get(&url)
.header("Authorization", format!("Bearer {token}"))
.header("Accept", "text/event-stream")
.send()
.await
.map_err(|e| format!("Failed to connect to SSE: {e}"))?;
if !response.status().is_success() {
return Err(format!(
"SSE connection failed with status: {}",
response.status()
));
}
log::info!("Connected to sync subscription at {url}");
let _ = app_handle.emit("sync-subscription-status", "connected");
let mut buffer = String::new();
let mut bytes_stream = response.bytes_stream();
use futures_util::StreamExt;
while running.load(Ordering::SeqCst) {
match tokio::time::timeout(Duration::from_secs(60), bytes_stream.next()).await {
Ok(Some(Ok(bytes))) => {
let chunk = String::from_utf8_lossy(&bytes);
buffer.push_str(&chunk);
while let Some(event_end) = buffer.find("\n\n") {
let event_str = buffer[..event_end].to_string();
buffer = buffer[event_end + 2..].to_string();
if let Some(event) = Self::parse_sse_event(&event_str) {
Self::handle_event(&event, work_tx);
}
}
}
Ok(Some(Err(e))) => {
return Err(format!("SSE stream error: {e}"));
}
Ok(None) => {
return Ok(());
}
Err(_) => {
log::debug!("SSE timeout, continuing...");
}
}
}
Ok(())
}
fn parse_sse_event(event_str: &str) -> Option<SubscribeEvent> {
let mut data_line = None;
for line in event_str.lines() {
if let Some(data) = line.strip_prefix("data:") {
data_line = Some(data.trim());
}
}
data_line.and_then(|data| serde_json::from_str(data).ok())
}
fn handle_event(event: &SubscribeEvent, work_tx: &mpsc::UnboundedSender<SyncWorkItem>) {
let Some(key) = &event.key else {
return;
};
if event.event_type == "ping" {
return;
}
let work_item = if key.starts_with("profiles/") {
key
.strip_prefix("profiles/")
.and_then(|s| s.strip_suffix(".tar.gz"))
.map(|s| SyncWorkItem::Profile(s.to_string()))
} else if key.starts_with("proxies/") {
key
.strip_prefix("proxies/")
.and_then(|s| s.strip_suffix(".json"))
.map(|s| SyncWorkItem::Proxy(s.to_string()))
} else if key.starts_with("groups/") {
key
.strip_prefix("groups/")
.and_then(|s| s.strip_suffix(".json"))
.map(|s| SyncWorkItem::Group(s.to_string()))
} else if key.starts_with("tombstones/") {
key.strip_prefix("tombstones/").and_then(|rest| {
if rest.starts_with("profiles/") {
rest
.strip_prefix("profiles/")
.and_then(|s| s.strip_suffix(".json"))
.map(|id| SyncWorkItem::Tombstone("profile".to_string(), id.to_string()))
} else if rest.starts_with("proxies/") {
rest
.strip_prefix("proxies/")
.and_then(|s| s.strip_suffix(".json"))
.map(|id| SyncWorkItem::Tombstone("proxy".to_string(), id.to_string()))
} else if rest.starts_with("groups/") {
rest
.strip_prefix("groups/")
.and_then(|s| s.strip_suffix(".json"))
.map(|id| SyncWorkItem::Tombstone("group".to_string(), id.to_string()))
} else {
None
}
})
} else {
None
};
if let Some(item) = work_item {
log::debug!("Queueing sync work: {:?}", item);
let _ = work_tx.send(item);
}
}
}
pub struct SubscriptionManager {
subscription: Option<SyncSubscription>,
work_tx: mpsc::UnboundedSender<SyncWorkItem>,
work_rx: Option<mpsc::UnboundedReceiver<SyncWorkItem>>,
}
impl Default for SubscriptionManager {
fn default() -> Self {
Self::new()
}
}
impl SubscriptionManager {
pub fn new() -> Self {
let (work_tx, work_rx) = mpsc::unbounded_channel();
Self {
subscription: None,
work_tx,
work_rx: Some(work_rx),
}
}
pub fn get_work_sender(&self) -> mpsc::UnboundedSender<SyncWorkItem> {
self.work_tx.clone()
}
pub fn take_work_receiver(&mut self) -> Option<mpsc::UnboundedReceiver<SyncWorkItem>> {
self.work_rx.take()
}
pub async fn start(&mut self, app_handle: tauri::AppHandle) -> Result<(), String> {
if self.subscription.is_some() {
return Ok(());
}
let subscription =
SyncSubscription::create_from_settings(&app_handle, self.work_tx.clone()).await?;
if let Some(sub) = subscription {
sub.start(app_handle).await;
self.subscription = Some(sub);
log::info!("Sync subscription manager started");
} else {
log::debug!("Sync not configured, subscription not started");
}
Ok(())
}
pub fn stop(&mut self) {
if let Some(sub) = &self.subscription {
sub.stop();
}
self.subscription = None;
log::info!("Sync subscription manager stopped");
}
pub fn is_running(&self) -> bool {
self.subscription.as_ref().is_some_and(|s| s.is_running())
}
}
src-tauri/src/sync/types.rs
+187
View File
@@ -0,0 +1,187 @@
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StatRequest {
pub key: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StatResponse {
pub exists: bool,
#[serde(rename = "lastModified")]
pub last_modified: Option<String>,
pub size: Option<u64>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PresignUploadRequest {
pub key: String,
#[serde(rename = "contentType")]
pub content_type: Option<String>,
#[serde(rename = "expiresIn")]
pub expires_in: Option<u64>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PresignUploadResponse {
pub url: String,
#[serde(rename = "expiresAt")]
pub expires_at: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PresignDownloadRequest {
pub key: String,
#[serde(rename = "expiresIn")]
pub expires_in: Option<u64>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PresignDownloadResponse {
pub url: String,
#[serde(rename = "expiresAt")]
pub expires_at: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DeleteRequest {
pub key: String,
#[serde(rename = "tombstoneKey")]
pub tombstone_key: Option<String>,
#[serde(rename = "deletedAt")]
pub deleted_at: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DeleteResponse {
pub deleted: bool,
#[serde(rename = "tombstoneCreated")]
pub tombstone_created: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ListRequest {
pub prefix: String,
#[serde(rename = "maxKeys")]
pub max_keys: Option<u32>,
#[serde(rename = "continuationToken")]
pub continuation_token: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ListObject {
pub key: String,
#[serde(rename = "lastModified")]
pub last_modified: String,
pub size: u64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ListResponse {
pub objects: Vec<ListObject>,
#[serde(rename = "isTruncated")]
pub is_truncated: bool,
#[serde(rename = "nextContinuationToken")]
pub next_continuation_token: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Tombstone {
pub id: String,
pub deleted_at: String,
}
// Batch presign types
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PresignUploadBatchItem {
pub key: String,
#[serde(rename = "contentType")]
pub content_type: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PresignUploadBatchRequest {
pub items: Vec<PresignUploadBatchItem>,
#[serde(rename = "expiresIn")]
pub expires_in: Option<u64>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PresignUploadBatchItemResponse {
pub key: String,
pub url: String,
#[serde(rename = "expiresAt")]
pub expires_at: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PresignUploadBatchResponse {
pub items: Vec<PresignUploadBatchItemResponse>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PresignDownloadBatchRequest {
pub keys: Vec<String>,
#[serde(rename = "expiresIn")]
pub expires_in: Option<u64>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PresignDownloadBatchItemResponse {
pub key: String,
pub url: String,
#[serde(rename = "expiresAt")]
pub expires_at: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PresignDownloadBatchResponse {
pub items: Vec<PresignDownloadBatchItemResponse>,
}
// Delete prefix types
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DeletePrefixRequest {
pub prefix: String,
#[serde(rename = "tombstoneKey")]
pub tombstone_key: Option<String>,
#[serde(rename = "deletedAt")]
pub deleted_at: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DeletePrefixResponse {
#[serde(rename = "deletedCount")]
pub deleted_count: u32,
#[serde(rename = "tombstoneCreated")]
pub tombstone_created: bool,
}
#[derive(Debug)]
pub enum SyncError {
NotConfigured,
NetworkError(String),
AuthError(String),
IoError(String),
SerializationError(String),
ConflictError(String),
InvalidData(String),
}
impl std::fmt::Display for SyncError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
SyncError::NotConfigured => write!(f, "Sync not configured"),
SyncError::NetworkError(msg) => write!(f, "Network error: {msg}"),
SyncError::AuthError(msg) => write!(f, "Authentication error: {msg}"),
SyncError::IoError(msg) => write!(f, "IO error: {msg}"),
SyncError::SerializationError(msg) => write!(f, "Serialization error: {msg}"),
SyncError::ConflictError(msg) => write!(f, "Conflict error: {msg}"),
SyncError::InvalidData(msg) => write!(f, "Invalid data: {msg}"),
}
}
}
impl std::error::Error for SyncError {}
pub type SyncResult<T> = Result<T, SyncError>;
src-tauri/tests/sync_e2e.rs
+729
View File
@@ -0,0 +1,729 @@
use donutbrowser_lib::sync::types::*;
use reqwest::Client;
use serde_json::json;
use std::env;
use std::fs;
use std::path::Path;
use tempfile::TempDir;
const TEST_TOKEN: &str = "test-sync-token";
fn get_sync_server_url() -> String {
env::var("SYNC_SERVER_URL").unwrap_or_else(|_| "http://localhost:3000".to_string())
}
/// Check if sync server is available and fail with a clear error message if not.
/// This ensures tests fail with helpful information rather than being silently ignored.
async fn ensure_sync_server_available() {
let client = Client::new();
let health_url = format!("{}/health", get_sync_server_url());
match client
.get(&health_url)
.timeout(std::time::Duration::from_secs(5))
.send()
.await
{
Ok(response) => {
if !response.status().is_success() {
panic!(
"Sync server is not healthy. Health check returned status: {}\n\
Server URL: {}\n\
Please ensure:\n\
1. MinIO is running (docker compose up -d in donut-sync/)\n\
2. donut-sync server is running (cd donut-sync && pnpm start:dev)\n\
3. SYNC_SERVER_URL environment variable is set correctly",
response.status(),
get_sync_server_url()
);
}
}
Err(e) => {
panic!(
"Cannot connect to sync server: {}\n\
Server URL: {}\n\
Please ensure:\n\
1. MinIO is running (docker compose up -d in donut-sync/)\n\
2. donut-sync server is running (cd donut-sync && pnpm start:dev)\n\
3. SYNC_SERVER_URL environment variable is set correctly\n\
4. Network connectivity is available",
e,
get_sync_server_url()
);
}
}
}
struct TestClient {
client: Client,
base_url: String,
token: String,
}
impl TestClient {
fn new() -> Self {
Self {
client: Client::new(),
base_url: get_sync_server_url(),
token: TEST_TOKEN.to_string(),
}
}
fn url(&self, path: &str) -> String {
format!("{}/v1/objects/{}", self.base_url, path)
}
async fn stat(&self, key: &str) -> Result<StatResponse, Box<dyn std::error::Error>> {
let response = self
.client
.post(self.url("stat"))
.header("Authorization", format!("Bearer {}", self.token))
.json(&json!({ "key": key }))
.send()
.await?;
let status = response.status();
if !status.is_success() {
let body = response.text().await.unwrap_or_default();
return Err(format!("stat failed with status {status}: {body}").into());
}
Ok(response.json().await?)
}
async fn presign_upload(
&self,
key: &str,
content_type: &str,
) -> Result<PresignUploadResponse, Box<dyn std::error::Error>> {
let response = self
.client
.post(self.url("presign-upload"))
.header("Authorization", format!("Bearer {}", self.token))
.json(&json!({
"key": key,
"contentType": content_type
}))
.send()
.await?;
let status = response.status();
if !status.is_success() {
let body = response.text().await.unwrap_or_default();
return Err(format!("presign-upload failed with status {status}: {body}").into());
}
Ok(response.json().await?)
}
async fn presign_download(
&self,
key: &str,
) -> Result<PresignDownloadResponse, Box<dyn std::error::Error>> {
let response = self
.client
.post(self.url("presign-download"))
.header("Authorization", format!("Bearer {}", self.token))
.json(&json!({ "key": key }))
.send()
.await?;
let status = response.status();
if !status.is_success() {
let body = response.text().await.unwrap_or_default();
return Err(format!("presign-download failed with status {status}: {body}").into());
}
Ok(response.json().await?)
}
async fn delete(
&self,
key: &str,
tombstone_key: Option<&str>,
) -> Result<DeleteResponse, Box<dyn std::error::Error>> {
let mut body = json!({ "key": key });
if let Some(tk) = tombstone_key {
body["tombstoneKey"] = json!(tk);
body["deletedAt"] = json!(chrono::Utc::now().to_rfc3339());
}
let response = self
.client
.post(self.url("delete"))
.header("Authorization", format!("Bearer {}", self.token))
.json(&body)
.send()
.await?;
let status = response.status();
if !status.is_success() {
let body_text = response.text().await.unwrap_or_default();
return Err(format!("delete failed with status {status}: {body_text}").into());
}
Ok(response.json().await?)
}
async fn upload_bytes(
&self,
url: &str,
data: &[u8],
content_type: &str,
) -> Result<(), Box<dyn std::error::Error>> {
let response = self
.client
.put(url)
.header("Content-Type", content_type)
.body(data.to_vec())
.send()
.await?;
if !response.status().is_success() {
let status = response.status();
let body = response.text().await.unwrap_or_default();
return Err(format!("Upload failed with status {status}: {body}").into());
}
Ok(())
}
async fn download_bytes(&self, url: &str) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
let response = self.client.get(url).send().await?;
let status = response.status();
if !status.is_success() {
let body = response.text().await.unwrap_or_default();
return Err(format!("Download failed with status {status}: {body}").into());
}
Ok(response.bytes().await?.to_vec())
}
}
fn create_test_profile_bundle(temp_dir: &Path) -> Vec<u8> {
use flate2::write::GzEncoder;
use flate2::Compression;
use tar::Builder;
let metadata = json!({
"id": "test-profile-id",
"name": "Test Profile",
"browser": "chromium",
"version": "120.0.0",
"release_type": "stable",
"sync_enabled": true,
"tags": ["test", "e2e"],
"note": "Test profile for e2e"
});
let profile_dir = temp_dir.join("profile");
fs::create_dir_all(&profile_dir).unwrap();
fs::write(profile_dir.join("test_file.txt"), "test content").unwrap();
let mut encoder = GzEncoder::new(Vec::new(), Compression::default());
{
let mut tar = Builder::new(&mut encoder);
let metadata_json = serde_json::to_string_pretty(&metadata).unwrap();
let mut header = tar::Header::new_gnu();
header.set_size(metadata_json.len() as u64);
header.set_mode(0o644);
header.set_cksum();
tar
.append_data(&mut header, "metadata.json", metadata_json.as_bytes())
.unwrap();
tar.append_dir_all("profile", &profile_dir).unwrap();
tar.finish().unwrap();
}
encoder.finish().unwrap()
}
fn extract_bundle(data: &[u8], target_dir: &Path) -> serde_json::Value {
use flate2::read::GzDecoder;
use tar::Archive;
let decoder = GzDecoder::new(data);
let mut archive = Archive::new(decoder);
archive.unpack(target_dir).unwrap();
let metadata_path = target_dir.join("metadata.json");
let metadata_content = fs::read_to_string(metadata_path).unwrap();
serde_json::from_str(&metadata_content).unwrap()
}
#[tokio::test]
async fn test_sync_server_health() {
ensure_sync_server_available().await;
let client = Client::new();
let url = format!("{}/health", get_sync_server_url());
let response = client.get(&url).send().await.unwrap();
assert!(response.status().is_success());
}
#[tokio::test]
async fn test_stat_nonexistent_key() {
ensure_sync_server_available().await;
let client = TestClient::new();
let result = client.stat("nonexistent-key").await.unwrap();
assert!(!result.exists);
}
#[tokio::test]
async fn test_upload_download_cycle() {
ensure_sync_server_available().await;
let client = TestClient::new();
let test_key = format!("test/e2e-rust-{}.txt", uuid::Uuid::new_v4());
let test_content = b"Hello from Rust e2e test!";
let presign = client
.presign_upload(&test_key, "text/plain")
.await
.unwrap();
client
.upload_bytes(&presign.url, test_content, "text/plain")
.await
.unwrap();
let stat = client.stat(&test_key).await.unwrap();
assert!(stat.exists);
assert_eq!(stat.size, Some(test_content.len() as u64));
let download_presign = client.presign_download(&test_key).await.unwrap();
let downloaded = client.download_bytes(&download_presign.url).await.unwrap();
assert_eq!(downloaded, test_content);
let delete_result = client.delete(&test_key, None).await.unwrap();
assert!(delete_result.deleted);
let final_stat = client.stat(&test_key).await.unwrap();
assert!(!final_stat.exists);
}
#[tokio::test]
async fn test_profile_bundle_upload_download() {
ensure_sync_server_available().await;
let client = TestClient::new();
let temp_dir = TempDir::new().unwrap();
let profile_id = uuid::Uuid::new_v4().to_string();
let test_key = format!("profiles/{}.tar.gz", profile_id);
let bundle = create_test_profile_bundle(temp_dir.path());
let presign = client
.presign_upload(&test_key, "application/gzip")
.await
.unwrap();
client
.upload_bytes(&presign.url, &bundle, "application/gzip")
.await
.unwrap();
let stat = client.stat(&test_key).await.unwrap();
assert!(stat.exists);
let download_presign = client.presign_download(&test_key).await.unwrap();
let downloaded = client.download_bytes(&download_presign.url).await.unwrap();
assert_eq!(downloaded.len(), bundle.len());
let extract_dir = temp_dir.path().join("extracted");
fs::create_dir_all(&extract_dir).unwrap();
let metadata = extract_bundle(&downloaded, &extract_dir);
assert_eq!(metadata["name"], "Test Profile");
assert_eq!(metadata["browser"], "chromium");
assert!(metadata["sync_enabled"].as_bool().unwrap());
let test_file = extract_dir.join("profile").join("test_file.txt");
assert!(test_file.exists());
let content = fs::read_to_string(test_file).unwrap();
assert_eq!(content, "test content");
client.delete(&test_key, None).await.unwrap();
}
#[tokio::test]
async fn test_tombstone_creation() {
ensure_sync_server_available().await;
let client = TestClient::new();
let test_key = format!("test/tombstone-test-{}.txt", uuid::Uuid::new_v4());
let tombstone_key = format!("tombstones/{}", test_key.replace("test/", ""));
let presign = client
.presign_upload(&test_key, "text/plain")
.await
.unwrap();
client
.upload_bytes(&presign.url, b"to be deleted", "text/plain")
.await
.unwrap();
let delete_result = client
.delete(&test_key, Some(&tombstone_key))
.await
.unwrap();
assert!(delete_result.deleted);
assert!(delete_result.tombstone_created);
let tombstone_stat = client.stat(&tombstone_key).await.unwrap();
assert!(tombstone_stat.exists);
client.delete(&tombstone_key, None).await.unwrap();
}
#[tokio::test]
async fn test_device_a_to_device_b_sync() {
ensure_sync_server_available().await;
let client = TestClient::new();
let temp_dir_a = TempDir::new().unwrap();
let temp_dir_b = TempDir::new().unwrap();
let profile_id = uuid::Uuid::new_v4().to_string();
let test_key = format!("profiles/{}.tar.gz", profile_id);
let bundle_a = create_test_profile_bundle(temp_dir_a.path());
let presign = client
.presign_upload(&test_key, "application/gzip")
.await
.unwrap();
client
.upload_bytes(&presign.url, &bundle_a, "application/gzip")
.await
.unwrap();
let download_presign = client.presign_download(&test_key).await.unwrap();
let downloaded_b = client.download_bytes(&download_presign.url).await.unwrap();
let extract_dir_b = temp_dir_b.path().join("extracted");
fs::create_dir_all(&extract_dir_b).unwrap();
let metadata_b = extract_bundle(&downloaded_b, &extract_dir_b);
assert_eq!(metadata_b["name"], "Test Profile");
assert_eq!(metadata_b["browser"], "chromium");
let test_file_b = extract_dir_b.join("profile").join("test_file.txt");
assert!(test_file_b.exists());
let content_b = fs::read_to_string(test_file_b).unwrap();
assert_eq!(content_b, "test content");
client.delete(&test_key, None).await.unwrap();
}
#[tokio::test]
async fn test_proxy_sync() {
ensure_sync_server_available().await;
let client = TestClient::new();
let proxy_id = uuid::Uuid::new_v4().to_string();
let test_key = format!("proxies/{}.json", proxy_id);
let proxy_data = json!({
"id": proxy_id,
"name": "Test Proxy",
"proxy_settings": {
"proxy_type": "http",
"host": "proxy.example.com",
"port": 8080,
"username": "user",
"password": "pass"
}
});
let proxy_json = serde_json::to_string(&proxy_data).unwrap();
let presign = client
.presign_upload(&test_key, "application/json")
.await
.unwrap();
client
.upload_bytes(&presign.url, proxy_json.as_bytes(), "application/json")
.await
.unwrap();
let stat = client.stat(&test_key).await.unwrap();
assert!(stat.exists);
let download_presign = client.presign_download(&test_key).await.unwrap();
let downloaded = client.download_bytes(&download_presign.url).await.unwrap();
let downloaded_proxy: serde_json::Value = serde_json::from_slice(&downloaded).unwrap();
assert_eq!(downloaded_proxy["name"], "Test Proxy");
assert_eq!(
downloaded_proxy["proxy_settings"]["host"],
"proxy.example.com"
);
client.delete(&test_key, None).await.unwrap();
}
#[tokio::test]
async fn test_group_sync() {
ensure_sync_server_available().await;
let client = TestClient::new();
let group_id = uuid::Uuid::new_v4().to_string();
let test_key = format!("groups/{}.json", group_id);
let group_data = json!({
"id": group_id,
"name": "Test Group"
});
let group_json = serde_json::to_string(&group_data).unwrap();
let presign = client
.presign_upload(&test_key, "application/json")
.await
.unwrap();
client
.upload_bytes(&presign.url, group_json.as_bytes(), "application/json")
.await
.unwrap();
let stat = client.stat(&test_key).await.unwrap();
assert!(stat.exists);
let download_presign = client.presign_download(&test_key).await.unwrap();
let downloaded = client.download_bytes(&download_presign.url).await.unwrap();
let downloaded_group: serde_json::Value = serde_json::from_slice(&downloaded).unwrap();
assert_eq!(downloaded_group["name"], "Test Group");
client.delete(&test_key, None).await.unwrap();
}
#[tokio::test]
async fn test_batch_presign_upload() {
ensure_sync_server_available().await;
let client = TestClient::new();
let profile_id = uuid::Uuid::new_v4().to_string();
let items = vec![
json!({
"key": format!("profiles/{}/files/file1.txt", profile_id),
"contentType": "text/plain"
}),
json!({
"key": format!("profiles/{}/files/file2.txt", profile_id),
"contentType": "text/plain"
}),
json!({
"key": format!("profiles/{}/files/subdir/file3.txt", profile_id),
"contentType": "text/plain"
}),
];
let response = client
.client
.post(client.url("presign-upload-batch"))
.header("Authorization", format!("Bearer {}", client.token))
.json(&json!({ "items": items }))
.send()
.await
.unwrap();
assert!(response.status().is_success());
let result: serde_json::Value = response.json().await.unwrap();
let items_result = result["items"].as_array().unwrap();
assert_eq!(items_result.len(), 3);
for item in items_result {
assert!(item["url"].as_str().is_some());
assert!(item["key"].as_str().is_some());
}
}
#[tokio::test]
async fn test_batch_presign_download() {
ensure_sync_server_available().await;
let client = TestClient::new();
let profile_id = uuid::Uuid::new_v4().to_string();
// First upload some files
let file_keys = vec![
format!("profiles/{}/files/file1.txt", profile_id),
format!("profiles/{}/files/file2.txt", profile_id),
];
for key in &file_keys {
let presign = client.presign_upload(key, "text/plain").await.unwrap();
client
.upload_bytes(&presign.url, b"test content", "text/plain")
.await
.unwrap();
}
// Now test batch download presign
let response = client
.client
.post(client.url("presign-download-batch"))
.header("Authorization", format!("Bearer {}", client.token))
.json(&json!({ "keys": file_keys }))
.send()
.await
.unwrap();
assert!(response.status().is_success());
let result: serde_json::Value = response.json().await.unwrap();
let items_result = result["items"].as_array().unwrap();
assert_eq!(items_result.len(), 2);
for item in items_result {
assert!(item["url"].as_str().is_some());
assert!(item["key"].as_str().is_some());
}
// Cleanup
for key in &file_keys {
client.delete(key, None).await.unwrap();
}
}
#[tokio::test]
async fn test_delete_prefix() {
ensure_sync_server_available().await;
let client = TestClient::new();
let profile_id = uuid::Uuid::new_v4().to_string();
let prefix = format!("profiles/{}/", profile_id);
// Upload multiple files under the profile prefix
let file_keys = vec![
format!("profiles/{}/manifest.json", profile_id),
format!("profiles/{}/metadata.json", profile_id),
format!("profiles/{}/files/file1.txt", profile_id),
format!("profiles/{}/files/subdir/file2.txt", profile_id),
];
for key in &file_keys {
let content_type = if key.ends_with(".json") {
"application/json"
} else {
"text/plain"
};
let presign = client.presign_upload(key, content_type).await.unwrap();
client
.upload_bytes(&presign.url, b"test content", content_type)
.await
.unwrap();
}
// Verify all files exist
for key in &file_keys {
let stat = client.stat(key).await.unwrap();
assert!(stat.exists, "File should exist before delete: {}", key);
}
// Delete with prefix
let tombstone_key = format!("tombstones/profiles/{}.json", profile_id);
let response = client
.client
.post(client.url("delete-prefix"))
.header("Authorization", format!("Bearer {}", client.token))
.json(&json!({
"prefix": prefix,
"tombstoneKey": tombstone_key
}))
.send()
.await
.unwrap();
assert!(response.status().is_success());
let result: serde_json::Value = response.json().await.unwrap();
assert_eq!(result["deletedCount"].as_u64().unwrap(), 4);
assert!(result["tombstoneCreated"].as_bool().unwrap());
// Verify all files are deleted
for key in &file_keys {
let stat = client.stat(key).await.unwrap();
assert!(
!stat.exists,
"File should be deleted after delete-prefix: {}",
key
);
}
// Verify tombstone exists
let tombstone_stat = client.stat(&tombstone_key).await.unwrap();
assert!(tombstone_stat.exists, "Tombstone should exist");
// Cleanup tombstone
client.delete(&tombstone_key, None).await.unwrap();
}
#[tokio::test]
async fn test_delta_sync_only_changed_files() {
ensure_sync_server_available().await;
let client = TestClient::new();
let profile_id = uuid::Uuid::new_v4().to_string();
// Simulate initial upload of 3 files
let file1_key = format!("profiles/{}/files/file1.txt", profile_id);
let file2_key = format!("profiles/{}/files/file2.txt", profile_id);
let file3_key = format!("profiles/{}/files/file3.txt", profile_id);
let presign1 = client
.presign_upload(&file1_key, "text/plain")
.await
.unwrap();
client
.upload_bytes(&presign1.url, b"content1", "text/plain")
.await
.unwrap();
let presign2 = client
.presign_upload(&file2_key, "text/plain")
.await
.unwrap();
client
.upload_bytes(&presign2.url, b"content2", "text/plain")
.await
.unwrap();
let presign3 = client
.presign_upload(&file3_key, "text/plain")
.await
.unwrap();
client
.upload_bytes(&presign3.url, b"content3", "text/plain")
.await
.unwrap();
// Get initial stats
let stat1_before = client.stat(&file1_key).await.unwrap();
let stat2_before = client.stat(&file2_key).await.unwrap();
let stat3_before = client.stat(&file3_key).await.unwrap();
// Wait a moment for timestamp differentiation
tokio::time::sleep(std::time::Duration::from_secs(1)).await;
// Simulate delta sync: only update file2
let presign2_update = client
.presign_upload(&file2_key, "text/plain")
.await
.unwrap();
client
.upload_bytes(&presign2_update.url, b"content2-updated", "text/plain")
.await
.unwrap();
// Check that file2's metadata changed
let stat2_after = client.stat(&file2_key).await.unwrap();
assert_ne!(
stat2_before.size, stat2_after.size,
"File2 size should have changed"
);
// Verify file1 and file3 are unchanged (same size)
let stat1_after = client.stat(&file1_key).await.unwrap();
let stat3_after = client.stat(&file3_key).await.unwrap();
assert_eq!(
stat1_before.size, stat1_after.size,
"File1 should be unchanged"
);
assert_eq!(
stat3_before.size, stat3_after.size,
"File3 should be unchanged"
);
// Cleanup
client.delete(&file1_key, None).await.unwrap();
client.delete(&file2_key, None).await.unwrap();
client.delete(&file3_key, None).await.unwrap();
}