Better API for stats printing

crates/librqbit/src/torrent_state/live/stats/snapshot.rs

@@ -14,8 +14,6 @@ pub struct StatsSnapshot {
     pub initially_needed_bytes: u64,
     pub remaining_bytes: u64,
     pub total_bytes: u64,
-    //    #[serde(skip)]
-    //    pub time: Instant,
     pub total_piece_download_ms: u64,
     pub peer_stats: AggregatePeerStats,
 }

crates/librqbit/src/torrent_state/mod.rs

@@ -1,12 +1,14 @@
 pub mod initializing;
 pub mod live;
 pub mod paused;
+pub mod stats;
 pub mod utils;
 
 use std::collections::HashSet;
 use std::net::SocketAddr;
 use std::path::Path;
 use std::path::PathBuf;
+use std::sync::atomic::Ordering;
 use std::sync::Arc;
 use std::sync::Weak;
 use std::time::Duration;
@@ -31,10 +33,12 @@ use url::Url;
 use crate::chunk_tracker::ChunkTracker;
 use crate::spawn_utils::spawn;
 use crate::spawn_utils::BlockingSpawner;
+use crate::torrent_state::stats::LiveStats;
 
 use initializing::TorrentStateInitializing;
 
 use self::paused::TorrentStatePaused;
+use self::stats::TorrentStats;
 
 pub enum ManagedTorrentState {
     Initializing(Arc<TorrentStateInitializing>),
@@ -251,12 +255,63 @@ impl ManagedTorrent {
         }
     }
 
+    pub fn stats(&self) -> TorrentStats {
+        let mut resp = TorrentStats {
+            total_bytes: self.info().lengths.total_length(),
+            state: "",
+            error: None,
+            progress_bytes: 0,
+            finished: false,
+            live: None,
+        };
+
+        self.with_state(|s| {
+            match s {
+                ManagedTorrentState::Initializing(i) => {
+                    resp.state = "initializing";
+                    resp.progress_bytes = i.checked_bytes.load(Ordering::Relaxed);
+                }
+                ManagedTorrentState::Paused(p) => {
+                    resp.state = "paused";
+                    resp.progress_bytes = p.have_bytes;
+                    resp.finished = p.have_bytes == resp.total_bytes;
+                }
+                ManagedTorrentState::Live(l) => {
+                    resp.state = "live";
+                    let live_stats = LiveStats::from(l.as_ref());
+                    resp.progress_bytes = live_stats.snapshot.have_bytes;
+                    resp.finished = resp.progress_bytes == resp.total_bytes;
+                    resp.live = Some(live_stats);
+                }
+                ManagedTorrentState::Error(e) => {
+                    resp.state = "error";
+                    resp.error = Some(format!("{:?}", e))
+                }
+                ManagedTorrentState::None => {
+                    resp.state = "error";
+                    resp.error = Some("bug: torrent in broken \"None\" state".to_string());
+                }
+            }
+            resp
+        })
+    }
+
     pub async fn wait_until_completed(&self) -> anyhow::Result<()> {
-        // TODO: rewrite
-        self.live()
-            .context("torrent isn't live")?
-            .wait_until_completed()
-            .await;
+        // TODO: rewrite, this polling is horrible
+        let live = loop {
+            let live = self.with_state(|s| match s {
+                ManagedTorrentState::Initializing(_) | ManagedTorrentState::Paused(_) => Ok(None),
+                ManagedTorrentState::Live(l) => Ok(Some(l.clone())),
+                ManagedTorrentState::Error(e) => bail!("{:?}", e),
+                ManagedTorrentState::None => bail!("bug: torrent state is None"),
+            })?;
+            if let Some(live) = live {
+                break live;
+            }
+            tokio::time::sleep(Duration::from_secs(1)).await;
+        };
+
+        live.wait_until_completed().await;
         Ok(())
     }
 }

crates/librqbit/src/torrent_state/stats.rs

@@ -0,0 +1,198 @@
+use std::time::Duration;
+
+use serde::Serialize;
+
+use super::{live::stats::snapshot::StatsSnapshot, TorrentStateLive};
+use size_format::SizeFormatterBinary as SF;
+
+#[derive(Serialize, Default, Debug)]
+pub struct LiveStats {
+    pub snapshot: StatsSnapshot,
+    pub average_piece_download_time: Option<Duration>,
+    pub download_speed: Speed,
+    pub time_remaining: Option<DurationWithHumanReadable>,
+}
+
+impl std::fmt::Display for LiveStats {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "down speed: {}", self.download_speed)?;
+        if let Some(time_remaining) = &self.time_remaining {
+            write!(f, " eta: {time_remaining}")?;
+        }
+        Ok(())
+    }
+}
+
+impl From<&TorrentStateLive> for LiveStats {
+    fn from(live: &TorrentStateLive) -> Self {
+        let snapshot = live.stats_snapshot();
+        let estimator = live.speed_estimator();
+
+        Self {
+            average_piece_download_time: snapshot.average_piece_download_time(),
+            snapshot,
+            download_speed: estimator.download_mbps().into(),
+            time_remaining: estimator.time_remaining().map(DurationWithHumanReadable),
+        }
+    }
+}
+
+#[derive(Serialize, Debug)]
+pub struct TorrentStats {
+    pub state: &'static str,
+    pub error: Option<String>,
+    pub progress_bytes: u64,
+    pub total_bytes: u64,
+    pub finished: bool,
+    pub live: Option<LiveStats>,
+}
+
+impl std::fmt::Display for TorrentStats {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}: ", self.state)?;
+        if let Some(error) = &self.error {
+            return write!(f, "{error}");
+        }
+        write!(
+            f,
+            "{} ({})",
+            self.progress_percent_human_readable(),
+            self.progress_bytes_human_readable()
+        )?;
+        if let Some(live) = &self.live {
+            write!(f, " [{live}]")?;
+        }
+        Ok(())
+    }
+}
+
+impl TorrentStats {
+    pub fn progress_percent_human_readable(&self) -> impl std::fmt::Display {
+        struct Percents {
+            progress: u64,
+            total: u64,
+        }
+        impl std::fmt::Display for Percents {
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                if self.total == 0 {
+                    return write!(f, "N/A");
+                }
+                let pct = self.progress as f64 / self.total as f64 * 100f64;
+                write!(f, "{pct:.2}%")
+            }
+        }
+        Percents {
+            progress: self.progress_bytes,
+            total: self.total_bytes,
+        }
+    }
+
+    pub fn progress_bytes_human_readable(&self) -> impl std::fmt::Display {
+        struct Progress {
+            progress: u64,
+            total: u64,
+        }
+        impl std::fmt::Display for Progress {
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                write!(f, "{} / {}", SF::new(self.progress), SF::new(self.total))
+            }
+        }
+        Progress {
+            progress: self.progress_bytes,
+            total: self.total_bytes,
+        }
+    }
+}
+
+fn format_seconds_to_time(seconds: u64, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    let hours = seconds / 3600;
+    let minutes = (seconds % 3600) / 60;
+    let seconds = seconds % 60;
+
+    if hours > 0 {
+        write!(f, "{}h {}m", hours, minutes)
+    } else if minutes > 0 {
+        write!(f, "{}m {}s", minutes, seconds)
+    } else {
+        write!(f, "{}s", seconds)
+    }
+}
+
+pub struct DurationWithHumanReadable(Duration);
+
+impl core::fmt::Display for DurationWithHumanReadable {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> core::fmt::Result {
+        format_seconds_to_time(self.0.as_secs(), f)
+    }
+}
+
+impl core::fmt::Debug for DurationWithHumanReadable {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self)
+    }
+}
+
+impl Serialize for DurationWithHumanReadable {
+    fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        #[derive(Serialize)]
+        struct Tmp {
+            duration: Duration,
+            human_readable: String,
+        }
+        Tmp {
+            duration: self.0,
+            human_readable: format!("{}", self),
+        }
+        .serialize(serializer)
+    }
+}
+
+#[derive(Default)]
+pub struct Speed {
+    pub mbps: f64,
+}
+
+impl Speed {
+    fn new(mbps: f64) -> Self {
+        Self { mbps }
+    }
+}
+
+impl From<f64> for Speed {
+    fn from(mbps: f64) -> Self {
+        Self::new(mbps)
+    }
+}
+
+impl core::fmt::Display for Speed {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:.2} MiB/s", self.mbps)
+    }
+}
+
+impl core::fmt::Debug for Speed {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self)
+    }
+}
+
+impl Serialize for Speed {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        #[derive(Serialize)]
+        struct Tmp {
+            mbps: f64,
+            human_readable: String,
+        }
+        Tmp {
+            mbps: self.mbps,
+            human_readable: format!("{:?}", self.mbps),
+        }
+        .serialize(serializer)
+    }
+}