refactor: centralize progress tracking and optimize logging levels (#75)

- Add ProgressTracker utility for unified progress reporting across
  download, flash, verify, and decompress operations
- Centralize configuration constants in config module (logging intervals,
  flash delays, paste limits)
- Add helper functions: bytes_to_mb(), bytes_to_gb(), strip_compression_ext()
- Optimize log levels: use debug for technical details, info for user events
- Enable XZ multithreaded optimization (lzma-rust2 optimization feature)

This reduces code duplication and improves maintainability by extracting
common progress tracking patterns into a reusable component.

Author: SuperKali

src-tauri/Cargo.toml

@@ -22,7 +22,7 @@ tokio = { version = "1", features = ["full"] }
 reqwest = { version = "0.12", default-features = false, features = ["json", "stream", "rustls-tls"] }
 futures-util = "0.3"
 # Multi-threaded decompression libraries
-lzma-rust2 = { version = "0.15", features = ["xz", "std"] }
+lzma-rust2 = { version = "0.15", features = ["xz", "std", "optimization"] }
 bzip2 = "0.4"
 flate2 = "1.0"
 zstd = "0.13"

src-tauri/src/config/mod.rs

@@ -54,6 +54,42 @@ pub mod flash {
 
     /// Progress log interval (percentage points)
     pub const LOG_INTERVAL_PERCENT: u64 = 6;
+
+    /// Delay after unmount before writing (milliseconds)
+    pub const UNMOUNT_DELAY_MS: u64 = 500;
+}
+
+/// Progress logging intervals
+pub mod logging {
+    /// SHA256 calculation buffer size
+    pub const SHA_BUFFER_SIZE: usize = 8192;
+
+    /// SHA256 progress log interval (MB)
+    pub const SHA_LOG_INTERVAL_MB: u64 = 50;
+
+    /// Download progress log interval (MB)
+    pub const DOWNLOAD_LOG_INTERVAL_MB: u64 = 10;
+
+    /// Write progress log interval (MB)
+    pub const WRITE_LOG_INTERVAL_MB: u64 = 512;
+
+    /// Decompression progress log interval (MB)
+    pub const DECOMPRESS_LOG_INTERVAL_MB: u64 = 100;
+
+    /// Linux sync interval for flush operations
+    pub const LINUX_SYNC_INTERVAL: u64 = 32 * 1024 * 1024;
+}
+
+/// Log paste service settings
+pub mod paste {
+    /// Maximum lines to show in truncated preview
+    pub const TRUNCATE_LINES: usize = 500;
+
+    /// Maximum log file size to upload (5 MB)
+    pub const MAX_LOG_SIZE: u64 = 5 * 1024 * 1024;
+
+    /// Maximum log lines to process
+    pub const MAX_LOG_LINES: usize = 10_000;
 }
 
 /// Device detection settings

src-tauri/src/decompress.rs

@@ -17,7 +17,7 @@ use zstd::stream::read::Decoder as ZstdDecoder;
 use crate::config;
 use crate::download::DownloadState;
 use crate::log_info;
-use crate::utils::get_recommended_threads;
+use crate::utils::{get_recommended_threads, strip_compression_ext, ProgressTracker};
 
 const MODULE: &str = "decompress";
 
@@ -104,6 +104,16 @@ fn decompress_with_reader_mt<R: Read>(
         BufWriter::with_capacity(config::download::DECOMPRESS_BUFFER_SIZE, output_file);
     let mut buffer = vec![0u8; config::download::CHUNK_SIZE];
 
+    // Progress tracking - we don't know the decompressed size (0), so track output bytes
+    // Use config interval for consistent logging
+    let operation_name = format!("Decompress ({})", format_name);
+    let mut tracker = ProgressTracker::new(
+        &operation_name,
+        MODULE,
+        0, // Unknown total size for decompression
+        config::logging::DECOMPRESS_LOG_INTERVAL_MB,
+    );
+
     loop {
         if state.is_cancelled.load(Ordering::SeqCst) {
             drop(buf_writer);
@@ -122,12 +132,18 @@ fn decompress_with_reader_mt<R: Read>(
         buf_writer
             .write_all(&buffer[..bytes_read])
             .map_err(|e| format!("Failed to write decompressed data: {}", e))?;
+
+        // ProgressTracker handles logging automatically
+        tracker.update(bytes_read as u64);
     }
 
     buf_writer
         .flush()
         .map_err(|e| format!("Failed to flush output: {}", e))?;
 
+    // Log final summary
+    tracker.finish();
+
     Ok(())
 }
 
@@ -143,11 +159,7 @@ pub fn decompress_local_file(
         .ok_or("Invalid filename")?;
 
     // Extract base filename (remove compression extension)
-    let base_filename = filename
-        .trim_end_matches(".xz")
-        .trim_end_matches(".gz")
-        .trim_end_matches(".bz2")
-        .trim_end_matches(".zst");
+    let base_filename = strip_compression_ext(filename);
 
     // Generate unique filename with timestamp to handle concurrent operations
     let timestamp = std::time::SystemTime::now()

src-tauri/src/download.rs

@@ -14,6 +14,7 @@ use tokio::sync::Mutex;
 
 use crate::config;
 use crate::decompress::decompress_with_rust_xz;
+use crate::utils::{bytes_to_mb, ProgressTracker};
 use crate::{log_debug, log_error, log_info, log_warn};
 
 const MODULE: &str = "download";
@@ -72,7 +73,7 @@ fn extract_filename(url: &str) -> Result<&str, String> {
 
 /// Fetch expected SHA256 from URL
 async fn fetch_expected_sha(client: &Client, sha_url: &str) -> Result<String, String> {
-    log_info!(MODULE, "Fetching SHA256 from: {}", sha_url);
+    log_debug!(MODULE, "Fetching SHA256 from: {}", sha_url);
 
     let response = client
         .get(sha_url)
@@ -104,13 +105,13 @@ async fn fetch_expected_sha(client: &Client, sha_url: &str) -> Result<String, St
         return Err(format!("Invalid SHA256 hash format: {}", hash));
     }
 
-    log_info!(MODULE, "Expected SHA256: {}", hash);
+    log_debug!(MODULE, "Expected SHA256: {}", hash);
     Ok(hash)
 }
 
 /// Calculate SHA256 of a file
 fn calculate_file_sha256(path: &Path, state: &Arc<DownloadState>) -> Result<String, String> {
-    log_info!(MODULE, "Calculating SHA256 of: {}", path.display());
+    log_debug!(MODULE, "Calculating SHA256 of: {}", path.display());
     log_debug!(
         MODULE,
         "File size: {:?} bytes",
@@ -150,7 +151,7 @@ fn calculate_file_sha256(path: &Path, state: &Arc<DownloadState>) -> Result<Stri
 
     let result = hasher.finalize();
     let hash = format!("{:x}", result);
-    log_info!(MODULE, "Calculated SHA256: {}", hash);
+    log_debug!(MODULE, "Calculated SHA256: {}", hash);
     Ok(hash)
 }
 
@@ -209,7 +210,7 @@ pub async fn download_image(
     let output_path = output_dir.join(output_filename);
 
     log_info!(MODULE, "Download requested: {}", url);
-    log_info!(MODULE, "Output path: {}", output_path.display());
+    log_debug!(MODULE, "Output path: {}", output_path.display());
 
     // Check if image is already in cache (also updates mtime for LRU)
     if let Some(cached_path) = crate::cache::get_cached_image(output_filename) {
@@ -250,17 +251,23 @@ pub async fn download_image(
         MODULE,
         "Download size: {} bytes ({:.2} MB)",
         total_size,
-        total_size as f64 / 1024.0 / 1024.0
+        bytes_to_mb(total_size)
     );
 
     // Create temp file for compressed data
     let temp_path = output_dir.join(format!("{}.downloading", filename));
     let mut temp_file =
         File::create(&temp_path).map_err(|e| format!("Failed to create temp file: {}", e))?;
 
-    // Download with progress
+    // Download with progress tracking
     let mut stream = response.bytes_stream();
     let mut downloaded: u64 = 0;
+    let mut tracker = ProgressTracker::new(
+        "Download",
+        MODULE,
+        total_size,
+        config::logging::DOWNLOAD_LOG_INTERVAL_MB,
+    );
 
     while let Some(chunk) = stream.next().await {
         if state.is_cancelled.load(Ordering::SeqCst) {
@@ -277,10 +284,11 @@ pub async fn download_image(
 
         downloaded += chunk.len() as u64;
         state.downloaded_bytes.store(downloaded, Ordering::SeqCst);
+        tracker.update(chunk.len() as u64);
     }
 
     drop(temp_file);
-    log_info!(MODULE, "Download complete: {} bytes", downloaded);
+    tracker.finish();
 
     // Verify SHA256 if URL provided
     if let Some(sha_url) = sha_url {

src-tauri/src/flash/linux/writer.rs

@@ -12,7 +12,8 @@ use std::sync::Arc;
 
 use crate::config;
 use crate::flash::{sync_device, unmount_device, FlashState};
-use crate::{log_error, log_info};
+use crate::utils::{bytes_to_gb, ProgressTracker};
+use crate::{log_debug, log_error, log_info};
 
 const MODULE: &str = "flash::linux::writer";
 
@@ -21,7 +22,7 @@ const MODULE: &str = "flash::linux::writer";
 async fn open_device_udisks2(device_path: &str) -> Result<File, String> {
     use std::collections::HashMap;
 
-    log_info!(MODULE, "Opening device via UDisks2: {}", device_path);
+    log_debug!(MODULE, "Opening device via UDisks2: {}", device_path);
 
     // Create UDisks2 client
     let client = udisks2::Client::new()
@@ -35,7 +36,7 @@ async fn open_device_udisks2(device_path: &str) -> Result<File, String> {
 
     let object_path = format!("/org/freedesktop/UDisks2/block_devices/{}", dev_name);
 
-    log_info!(MODULE, "UDisks2 object path: {}", object_path);
+    log_debug!(MODULE, "UDisks2 object path: {}", object_path);
 
     // Get the block device object
     let object = client
@@ -56,7 +57,7 @@ async fn open_device_udisks2(device_path: &str) -> Result<File, String> {
         .await
         .map_err(|e| format!("Failed to open device (polkit auth may have failed): {}", e))?;
 
-    log_info!(MODULE, "Device opened successfully via UDisks2");
+    log_debug!(MODULE, "Device opened successfully via UDisks2");
 
     // Convert the file descriptor to a File
     // OwnedFd implements AsRawFd, so we get the raw fd and create a File from it
@@ -72,7 +73,7 @@ async fn open_device_udisks2(device_path: &str) -> Result<File, String> {
 fn open_device_direct(device_path: &str) -> Result<File, String> {
     use std::fs::OpenOptions;
 
-    log_info!(MODULE, "Attempting direct device open: {}", device_path);
+    log_debug!(MODULE, "Attempting direct device open: {}", device_path);
 
     OpenOptions::new()
         .read(true)
@@ -108,23 +109,25 @@ pub async fn flash_image(
         MODULE,
         "Image size: {} bytes ({:.2} GB)",
         image_size,
-        image_size as f64 / 1024.0 / 1024.0 / 1024.0
+        bytes_to_gb(image_size)
     );
 
     // Unmount the device first
     log_info!(MODULE, "Unmounting device partitions...");
     unmount_device(device_path)?;
 
     // Small delay to ensure unmount completes
-    std::thread::sleep(std::time::Duration::from_millis(500));
+    std::thread::sleep(std::time::Duration::from_millis(
+        config::flash::UNMOUNT_DELAY_MS,
+    ));
 
     // Try to open device via UDisks2 first (handles polkit auth)
     // Fall back to direct open if UDisks2 fails (e.g., if running as root)
-    log_info!(MODULE, "Opening device for writing...");
+    log_debug!(MODULE, "Opening device for writing...");
     let mut device = match open_device_udisks2(device_path).await {
         Ok(file) => file,
         Err(e) => {
-            log_info!(MODULE, "UDisks2 open failed ({}), trying direct open...", e);
+            log_debug!(MODULE, "UDisks2 open failed ({}), trying direct open...", e);
             open_device_direct(device_path)?
         }
     };
@@ -143,11 +146,18 @@ pub async fn flash_image(
     let mut buffer = vec![0u8; chunk_size];
     let mut written: u64 = 0;
 
+    // Use ProgressTracker for automatic progress logging
+    let mut tracker = ProgressTracker::new(
+        "Write",
+        MODULE,
+        image_size,
+        config::logging::WRITE_LOG_INTERVAL_MB,
+    );
+
     log_info!(MODULE, "Writing image...");
 
-    // Sync interval: sync every 32MB to show real progress (not just cache writes)
+    // Sync interval to show real progress (not just cache writes)
     // This ensures the progress bar reflects actual disk writes, not just memory cache
-    const SYNC_INTERVAL: u64 = 32 * 1024 * 1024;
     let mut bytes_since_sync: u64 = 0;
 
     loop {
@@ -172,25 +182,21 @@ pub async fn flash_image(
         bytes_since_sync += bytes_read as u64;
 
         // Periodic sync to flush data to disk and show real progress
-        if bytes_since_sync >= SYNC_INTERVAL {
+        if bytes_since_sync >= config::logging::LINUX_SYNC_INTERVAL {
             unsafe {
                 libc::fdatasync(device_fd);
             }
             bytes_since_sync = 0;
             state.written_bytes.store(written, Ordering::SeqCst);
         }
 
-        // Log progress every 512MB
-        if written % (512 * 1024 * 1024) == 0 {
-            log_info!(
-                MODULE,
-                "Progress: {:.1}%",
-                (written as f64 / image_size as f64) * 100.0
-            );
-        }
+        // ProgressTracker handles logging automatically
+        tracker.update(bytes_read as u64);
     }
 
-    log_info!(MODULE, "Write complete, syncing...");
+    // Log final summary
+    tracker.finish();
+    log_debug!(MODULE, "Syncing...");
 
     // Sync
     device.flush().ok();
@@ -228,7 +234,7 @@ fn quick_erase(device: &mut File) -> Result<(), String> {
     let erase_size = config::flash::QUICK_ERASE_SIZE;
     let chunk_size = config::flash::ERASE_CHUNK_SIZE;
 
-    log_info!(
+    log_debug!(
         MODULE,
         "Quick erase: writing zeros to first {} MB",
         erase_size / (1024 * 1024)
@@ -258,7 +264,7 @@ fn quick_erase(device: &mut File) -> Result<(), String> {
         .seek(SeekFrom::Start(0))
         .map_err(|e| format!("Failed to seek to start: {}", e))?;
 
-    log_info!(MODULE, "Quick erase complete");
+    log_debug!(MODULE, "Quick erase complete");
     Ok(())
 }