Implement progress bar

Author: cdcseacave

p2p-cli/src/cli.rs

@@ -80,11 +80,7 @@ pub struct TransferParams {
     #[arg(long, value_parser = parse_bandwidth_arg, default_value = "0")]
     pub max_speed: u64,
 
-    /// Enable automatic reconnection on network failures (default: enabled, use --auto-reconnect=false to disable)
-    #[arg(long, default_value = "true", action = clap::ArgAction::Set)]
-    pub auto_reconnect: bool,
-
-    /// Maximum reconnection attempts (0 = unlimited)
+    /// Maximum reconnection attempts on network failures (0 = unlimited, 1 = no retry)
     #[arg(long, default_value = "5")]
     pub max_retries: u32,
 }

p2p-cli/src/discover.rs

@@ -32,7 +32,7 @@ pub async fn handle_discover(timeout_secs: u64, port: u16) -> Result<()> {
     // Get discovered peers
     let peers = manager.get_peers().await;
 
-    info!("\n📡 Discovered {} peer(s):", peers.len());
+    info!("📡 Discovered {} peer(s):", peers.len());
     for (idx, peer) in peers.iter().enumerate() {
         info!(
             "  [{}] {} - {} ({})",

p2p-cli/src/receive.rs

@@ -46,18 +46,18 @@ pub async fn handle_receive(
     )
     .await?;
 
-    info!("  ✓ Session established");
+    info!("✅ Session established");
     info!("    Peer: {}", session.peer_device_id());
     info!("    Compression: {}", session.config().compression_enabled);
 
-    info!("\n📁 Session ready - waiting for incoming transfers...");
+    info!("📁 Session ready - waiting for incoming transfers...");
     info!("  (Press Ctrl+C to exit)");
 
-    // Run event loop - automatically receives incoming transfers
+    // Run event loop - automatically receives incoming transfers with progress display
     // The loop continues until the peer closes the connection
-    session.run_event_loop(&output, auto_accept).await?;
+    session.run_event_loop(&output, auto_accept, true).await?;
 
-    info!("\n✅ Session ended");
+    info!("✅ Session ended");
 
     Ok(())
 }

p2p-cli/src/resume.rs

@@ -1,12 +1,11 @@
 //! Resume operations
 
 use anyhow::Result;
-use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
 use p2p_core::{
     handshake::HandshakeClient,
     network::tcp::TcpConnection,
     protocol::{Capabilities, ConfigMessage},
-    transfer_folder::{FolderProgress, FolderTransferSession, FolderTransferState},
+    transfer_folder::{FolderTransferSession, FolderTransferState},
     Uuid,
 };
 use std::{net::SocketAddr, path::PathBuf};
@@ -87,51 +86,32 @@ pub async fn handle_resume(transfer_id: String, to: String, path: PathBuf) -> Re
         });
     }));
 
-    // Set up progress callback
-    let multi = MultiProgress::new();
+    // Create progress state for unified progress tracking
+    // Initialize with already completed bytes for resume
+    let mut progress = p2p_core::progress::ProgressState::new(state.total_bytes);
+    // Add the bytes already transferred
+    progress.add_bytes(state.transferred_bytes);
 
-    let overall_pb = multi.add(ProgressBar::new(100));
-    overall_pb.set_style(
-        ProgressStyle::default_bar()
-            .template("[{elapsed_precise}] {bar:40.cyan/blue} {pos}/{len} files ({percent}%)")
-            .unwrap()
-            .progress_chars("=>-"),
-    );
-
-    let current_pb = multi.add(ProgressBar::new(100));
-    current_pb.set_style(
-        ProgressStyle::default_bar()
-            .template("  Current: {msg} {bar:40.green/yellow} {bytes}/{total_bytes} ({percent}%)")
-            .unwrap()
-            .progress_chars("=>-"),
-    );
-
-    session.set_progress_callback(Box::new(move |progress: FolderProgress| {
-        overall_pb.set_length(progress.total_files as u64);
-        overall_pb.set_position(progress.completed_files as u64);
-
-        if let Some(file) = &progress.current_file {
-            current_pb.set_message(file.clone());
-            current_pb.set_position((progress.current_file_progress * 100.0) as u64);
-        }
+    // Resume transfer with signal handling
+    info!("📁 Resuming folder transfer...");
 
-        if progress.completed_files == progress.total_files {
-            overall_pb.finish_with_message("Complete!");
-            current_pb.finish_and_clear();
-        }
-    }));
+    // Use the unified send_folder method with existing state
+    let reconnect_config = p2p_core::reconnect::ReconnectConfig {
+        max_attempts: 1, // Single attempt, no auto-reconnect for manual resume command
+        initial_backoff_secs: 3,
+        max_backoff_secs: 180,
+        exponential: true,
+    };
 
-    // Resume transfer with signal handling
-    info!("\n📁 Resuming folder transfer...");
     tokio::select! {
-        result = session.resume_send_folder(&path, &state) => {
+        result = session.send_folder(&path, &reconnect_config, Some(&state_path), None, Some(&state), Some(&mut progress)) => {
             result?;
             let _ = tokio::fs::remove_file(&state_path).await;
-            info!("\n✅ Transfer resumed and completed!");
+            info!("✅ Transfer resumed and completed!");
             info!("  State file removed");
         }
         _ = signal::ctrl_c() => {
-            warn!("\n⚠️  Transfer interrupted again. State has been saved.");
+            warn!("⚠️  Transfer interrupted again. State has been saved.");
             info!("  Use 'p2p-transfer resume {} --to {} --path {}' to continue",
                 transfer_id, to, path.display());
             return Ok(());

p2p-cli/src/send.rs

@@ -1,11 +1,10 @@
 //! Send operations
 
 use anyhow::Result;
-use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
 use p2p_core::{
     protocol::{Capabilities, ConfigMessage},
     session::P2PSession,
-    transfer_folder::{FolderProgress, FolderTransferState},
+    transfer_folder::FolderTransferState,
     Uuid,
 };
 use std::path::{Path, PathBuf};
@@ -73,13 +72,13 @@ pub async fn handle_send(
     )
     .await?;
 
-    info!("  ✓ Session established");
+    info!("✅ Session established");
     info!("    Peer: {}", session.peer_device_id());
     info!("    Capabilities: {:?}", session.capabilities());
 
     // Send file or folder with signal handling (unified)
     let result = tokio::select! {
-        result = send(&mut session, &path, config, transfer_params.auto_reconnect, transfer_params.max_retries) => {
+        result = send(&mut session, &path, config, transfer_params.max_retries) => {
             result
         }
         _ = signal::ctrl_c() => {
@@ -89,11 +88,11 @@ pub async fn handle_send(
 
     match result {
         Ok(_) => {
-            info!("\n✅ Transfer complete!");
+            info!("✅ Transfer complete!");
             Ok(())
         }
         Err(e) => {
-            warn!("\n⚠️  Transfer interrupted: {}", e);
+            warn!("⚠️  Transfer interrupted: {}", e);
             info!("  State has been saved. Use 'p2p-transfer resume <transfer-id>' to continue");
             Err(e)
         }
@@ -104,15 +103,14 @@ async fn send(
     session: &mut P2PSession,
     path: &Path,
     _config: ConfigMessage,
-    auto_reconnect: bool,
     max_retries: u32,
 ) -> Result<()> {
     let base_name = path.file_name().unwrap().to_string_lossy().to_string();
 
     if path.is_file() {
-        info!("\n📄 Sending file: {}", base_name);
+        info!("📄 Sending file: {}", base_name);
     } else {
-        info!("\n📁 Sending folder: {}", base_name);
+        info!("📁 Sending folder: {}", base_name);
     }
 
     let config = session.config();
@@ -125,15 +123,13 @@ async fn send(
         );
     }
 
-    if auto_reconnect {
-        info!(
-            "   Auto-reconnect enabled (max retries: {})",
-            if max_retries == 0 {
-                "∞".to_string()
-            } else {
-                max_retries.to_string()
-            }
-        );
+    // Display reconnection behavior based on max_retries
+    if max_retries == 0 {
+        info!("   Auto-reconnect: enabled (unlimited retries)");
+    } else if max_retries == 1 {
+        info!("   Auto-reconnect: disabled (no retry)");
+    } else {
+        info!("   Auto-reconnect: enabled (max {} retries)", max_retries);
     }
 
     // Generate transfer ID for this operation
@@ -144,86 +140,45 @@ async fn send(
 
     // Keep state in memory using Arc<Mutex> for thread-safe access
     let current_state = std::sync::Arc::new(std::sync::Mutex::new(None::<FolderTransferState>));
-
-    // Create multi-progress for overall and per-file progress
-    let multi = MultiProgress::new();
-
-    let overall_pb = multi.add(ProgressBar::new(100));
-    overall_pb.set_style(
-        ProgressStyle::default_bar()
-            .template("[{elapsed_precise}] {bar:40.cyan/blue} {pos}/{len} files ({percent}%)")
-            .unwrap()
-            .progress_chars("=>-"),
-    );
-
-    let current_pb = multi.add(ProgressBar::new(100));
-    current_pb.set_style(
-        ProgressStyle::default_bar()
-            .template("  Current: {msg} {bar:40.green/yellow} {bytes}/{total_bytes} ({percent}%)")
-            .unwrap()
-            .progress_chars("=>-"),
-    );
-
-    // Create progress callback
-    let progress_callback = Box::new(move |progress: FolderProgress| {
-        // Update overall progress
-        overall_pb.set_length(progress.total_files as u64);
-        overall_pb.set_position(progress.completed_files as u64);
-
-        // Update current file progress
-        if let Some(file) = &progress.current_file {
-            current_pb.set_message(file.clone());
-            current_pb.set_position((progress.current_file_progress * 100.0) as u64);
-        }
-
-        // If all files complete, finish both bars
-        if progress.completed_files == progress.total_files {
-            overall_pb.finish_with_message("Complete!");
-            current_pb.finish_and_clear();
+    // Create progress state for unified progress tracking
+    let mut progress = p2p_core::progress::ProgressState::new(0);
+
+    // Create state callback to update in-memory state
+    let current_state_for_callback = current_state.clone();
+    let state_callback = Box::new(move |state: &FolderTransferState| {
+        if let Ok(mut guard) = current_state_for_callback.lock() {
+            *guard = Some(state.clone());
         }
     });
 
-    // Send file or folder with state tracking (unified method)
-    let result = if auto_reconnect {
-        // Create state callback to update in-memory state
-        let current_state_for_callback = current_state.clone();
-        let state_callback = Box::new(move |state: &FolderTransferState| {
-            if let Ok(mut guard) = current_state_for_callback.lock() {
-                *guard = Some(state.clone());
-            }
-        });
-
-        // Use auto-reconnect wrapper with in-memory state
-        let reconnect_config = p2p_core::reconnect::ReconnectConfig {
-            max_attempts: max_retries,
-            initial_backoff_secs: 3,
-            max_backoff_secs: 180,
-            exponential: true,
-        };
+    // Configure reconnection behavior
+    let reconnect_config = p2p_core::reconnect::ReconnectConfig {
+        max_attempts: max_retries,
+        initial_backoff_secs: 3,
+        max_backoff_secs: 180,
+        exponential: true,
+    };
 
-        // Create state provider closure that reads from in-memory state
-        let state_for_reconnect = current_state.clone();
-        let state_provider = Box::new(move || {
-            state_for_reconnect
-                .lock()
-                .ok()
-                .and_then(|guard| guard.clone())
-        });
+    // Create state provider closure that reads from in-memory state
+    let state_for_reconnect = current_state.clone();
+    let state_provider = Box::new(move || {
+        state_for_reconnect
+            .lock()
+            .ok()
+            .and_then(|guard| guard.clone())
+    });
 
-        session
-            .send_path_with_reconnect(
-                path,
-                Some(progress_callback),
-                Some(state_callback),
-                &reconnect_config,
-                Some(&state_file),
-                Some(state_provider),
-            )
-            .await
-    } else {
-        // Regular send without auto-reconnect - state stays in memory only
-        session.send_path(path, Some(progress_callback)).await
-    };
+    // Send file or folder with state tracking (unified method)
+    let result = session
+        .send_path(
+            path,
+            Some(&mut progress),
+            Some(state_callback),
+            &reconnect_config,
+            Some(&state_file),
+            Some(state_provider),
+        )
+        .await;
 
     match result {
         Ok(_) => {
@@ -243,7 +198,7 @@ async fn send(
                     let _ = tokio::fs::remove_file(&state_file).await;
                 }
             }
-            info!("  ✓ Transfer complete");
+            info!("✅ Transfer complete!");
             Ok(())
         }
         Err(e) => {

p2p-core/Cargo.toml

@@ -25,6 +25,7 @@ serde_json = "1.0.145"
 rand = "0.8"
 dirs = "5.0"
 local-ip-address = "0.6"
+indicatif = "0.17"
 
 [dev-dependencies]
 tokio-test = "0.4"

p2p-core/src/lib.rs

@@ -12,6 +12,7 @@ pub mod handshake;
 pub mod history; // Transfer history tracking
 pub mod nat; // NAT traversal and hole punching
 pub mod network;
+pub mod progress; // Unified progress tracking
 pub mod protocol;
 pub mod reconnect; // Auto-reconnect with exponential backoff
 pub mod session; // High-level session management