downloader: Add better progress updates with rate limiting

Author: cyberphantom52

src/downloader/mod.rs

@@ -1,9 +1,11 @@
 mod handle;
 mod manager;
+mod progress;
 mod types;
 mod worker;
 
 pub use handle::DownloadHandle;
 pub use manager::*;
+pub use progress::DownloadProgress;
 pub use types::*;
 pub(self) use worker::download_thread;

src/downloader/progress.rs

@@ -0,0 +1,131 @@
+use std::time::{Duration, Instant};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct DownloadProgress {
+    bytes_downloaded: u64,
+    total_bytes: Option<u64>,
+    speed_bps: Option<u64>,
+    eta: Option<Duration>,
+
+    // For calculations
+    start_time: Instant,
+    last_update: Instant,
+    last_speed_update: Instant,
+    last_bytes_for_speed: u64,
+    update_interval: Duration,
+}
+
+impl std::fmt::Display for DownloadProgress {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let percent = self.percent().unwrap_or(0.0);
+        let speed = self
+            .speed()
+            .map(|s| format!("{:.2} B/s", s))
+            .unwrap_or("N/A".to_string());
+        let eta = self
+            .eta
+            .map(|d| format!("{:.2?}", d))
+            .unwrap_or("N/A".to_string());
+        let elapsed = self.elapsed();
+
+        write!(
+            f,
+            "Downloaded: {} bytes, Total: {:?}, Speed: {}, ETA: {}, Elapsed: {:.2?}, Progress: {:.2}%",
+            self.bytes_downloaded,
+            self.total_bytes,
+            speed,
+            eta,
+            elapsed,
+            percent
+        )
+    }
+}
+
+impl DownloadProgress {
+    pub fn new(bytes_downloaded: u64, total_bytes: Option<u64>, update_interval: Duration) -> Self {
+        let now = Instant::now();
+        Self {
+            bytes_downloaded,
+            total_bytes,
+            speed_bps: None,
+            eta: None,
+
+            start_time: now,
+            last_update: now,
+            last_speed_update: now,
+            last_bytes_for_speed: bytes_downloaded,
+            update_interval,
+        }
+    }
+
+    pub fn update(&self, bytes_downloaded: u64) -> Option<Self> {
+        fn new_update(
+            progress: &DownloadProgress,
+            bytes_downloaded: u64,
+            instant: Instant,
+        ) -> DownloadProgress {
+            DownloadProgress {
+                eta: None,
+                last_update: instant,
+                bytes_downloaded,
+                total_bytes: progress.total_bytes,
+                speed_bps: progress.speed_bps,
+                start_time: progress.start_time,
+                last_speed_update: progress.last_speed_update,
+                last_bytes_for_speed: progress.last_bytes_for_speed,
+                update_interval: progress.update_interval,
+            }
+        }
+
+        let now = Instant::now();
+
+        if now.duration_since(self.last_update) < self.update_interval {
+            return None;
+        }
+        let mut new_update = new_update(self, bytes_downloaded, now);
+
+        if now.duration_since(self.last_speed_update) >= Duration::from_secs(1) {
+            let byte_diff = (bytes_downloaded - self.last_bytes_for_speed) as f64;
+            let time_diff = now.duration_since(self.last_speed_update).as_secs_f64();
+
+            new_update.last_speed_update = now;
+            new_update.last_bytes_for_speed = bytes_downloaded;
+            new_update.speed_bps = Some((byte_diff / time_diff) as u64);
+        };
+
+        if let (Some(speed), Some(total)) = (new_update.speed_bps, self.total_bytes) {
+            if speed > 0 {
+                let remaining = total.saturating_sub(bytes_downloaded);
+                new_update.eta = Some(Duration::from_secs(remaining / speed));
+            }
+        };
+
+        Some(new_update)
+    }
+
+    pub fn percent(&self) -> Option<f64> {
+        self.total_bytes.map(|total| {
+            if total == 0 {
+                0.0
+            } else {
+                (self.bytes_downloaded as f64 / total as f64) * 100.0
+            }
+        })
+    }
+
+    pub fn total_bytes(&self) -> Option<u64> {
+        self.total_bytes
+    }
+
+    pub fn bytes_downloaded(&self) -> u64 {
+        self.bytes_downloaded
+    }
+
+    pub fn speed(&self) -> Option<u64> {
+        self.speed_bps
+    }
+
+    pub fn elapsed(&self) -> Duration {
+        self.start_time.elapsed()
+    }
+}

src/downloader/types.rs

@@ -1,6 +1,7 @@
+use super::DownloadProgress;
 use crate::Error;
 use reqwest::Url;
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 use tokio::{
     fs::File,
     sync::{oneshot, watch},
@@ -16,12 +17,6 @@ pub(crate) struct DownloadRequest {
     pub cancel: CancellationToken,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct DownloadProgress {
-    pub bytes_downloaded: u64,
-    pub total_bytes: Option<u64>,
-}
-
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum Status {
     Queued,

src/downloader/worker.rs

@@ -80,15 +80,6 @@ pub(super) async fn download_thread(client: Client, mut req: DownloadRequest) {
 }
 
 async fn download(client: Client, req: &mut DownloadRequest) -> Result<File, Error> {
-    let update_progress = |bytes_downloaded: u64, total_bytes: Option<u64>| {
-        req.status
-            .send(Status::InProgress(DownloadProgress {
-                bytes_downloaded,
-                total_bytes,
-            }))
-            .ok();
-    };
-
     let mut response = client
         .get(req.url.as_ref())
         .send()
@@ -103,7 +94,10 @@ async fn download(client: Client, req: &mut DownloadRequest) -> Result<File, Err
     }
     let mut file = File::create(&req.destination).await?;
 
-    update_progress(bytes_downloaded, total_bytes);
+    let update_interval = Duration::from_millis(250);
+    let mut progress = DownloadProgress::new(bytes_downloaded, total_bytes, update_interval);
+    req.status.send(Status::InProgress(progress)).ok();
+
     loop {
         tokio::select! {
             _ = req.cancel.cancelled() => {
@@ -116,7 +110,10 @@ async fn download(client: Client, req: &mut DownloadRequest) -> Result<File, Err
                     Ok(Some(chunk)) => {
                         file.write_all(&chunk).await?;
                         bytes_downloaded += chunk.len() as u64;
-                        update_progress(bytes_downloaded, total_bytes);
+                        if let Some(new_progress) = progress.update(bytes_downloaded) {
+                            progress = new_progress;
+                        }
+                        req.status.send(Status::InProgress(progress)).ok();
                     }
                     Ok(None) => break,
                     Err(e) => {
@@ -128,7 +125,6 @@ async fn download(client: Client, req: &mut DownloadRequest) -> Result<File, Err
             }
         }
     }
-    update_progress(bytes_downloaded, total_bytes);
 
     // Ensure the data is written to disk
     file.sync_all().await?;