rsynko_manager/
transfer.rs

1use alux_ext::ext;
2use std::path::Path;
3use std::time::Duration;
4
5/// Specifies what one transfer states about its own progress.
6pub trait TransferViewAlg {
7    /// Observes retrieved bytes.
8    fn transferred(&self) -> u64;
9    /// Observes expected bytes when the source states them.
10    fn transfer_total(&self) -> Option<u64>;
11    /// Observes elapsed transfer time.
12    fn transfer_elapsed(&self) -> Duration;
13    /// Observes whether the transfer reached terminal success.
14    fn transfer_complete(&self) -> bool;
15    /// Observes the path publication will produce once an interpreter states one.
16    fn transfer_destination(&self) -> Option<&Path>;
17    /// Observes the concise reason a transfer failed.
18    fn transfer_summary(&self) -> Option<&str>;
19    /// Observes the diagnostic accompanying a failure.
20    fn transfer_detail(&self) -> Option<&str>;
21}
22
23/// Derives rate, remaining time, and completed share from observed bytes and elapsed time.
24#[ext(name = TransferProgressExt)]
25pub impl<This> This
26where
27    This: TransferViewAlg,
28{
29    /// Derives average retrieved bytes per second once progress has duration.
30    fn bytes_per_second(&self) -> Option<u64> {
31        let elapsed = self.transfer_elapsed().as_nanos();
32        let transferred = self.transferred();
33        if transferred == 0 || elapsed == 0 {
34            return None;
35        }
36        let rate = u128::from(transferred).saturating_mul(1_000_000_000) / elapsed;
37        Some(u64::try_from(rate.max(1)).unwrap_or(u64::MAX))
38    }
39
40    /// Derives remaining time from average progress once the expected byte count is known.
41    fn estimated_remaining(&self) -> Option<Duration> {
42        let total = self.transfer_total()?;
43        let elapsed = self.transfer_elapsed().as_nanos();
44        let transferred = self.transferred();
45        if transferred == 0 || elapsed == 0 {
46            return None;
47        }
48        let remaining = total.saturating_sub(transferred);
49        let nanos = u128::from(remaining).saturating_mul(elapsed) / u128::from(transferred);
50        Some(Duration::from_nanos(
51            u64::try_from(nanos).unwrap_or(u64::MAX),
52        ))
53    }
54
55    /// Derives the completed share as whole percent once it is known.
56    fn percent(&self) -> Option<u16> {
57        if self.transfer_complete() {
58            return Some(100);
59        }
60        let total = self.transfer_total()?;
61        if total == 0 {
62            return Some(0);
63        }
64        let percent = u128::from(self.transferred()).saturating_mul(100) / u128::from(total);
65        Some(u16::try_from(percent.min(100)).unwrap_or(100))
66    }
67}
68
69/// Denotes the lifecycle phase of one queued transfer.
70#[derive(Clone, Copy, Debug, PartialEq, Eq)]
71pub enum TransferPhase {
72    /// Denotes an entry ready to be scheduled.
73    Ready,
74    /// Denotes an enabled entry waiting for an interpreter to schedule it.
75    Waiting,
76    /// Denotes an interpreter stating what the request would do instead of doing it.
77    Rehearsing,
78    /// Denotes extraction and format selection.
79    Extracting,
80    /// Denotes incremental resource retrieval.
81    Downloading,
82    /// Denotes a cooperatively suspended active transfer.
83    Paused,
84    /// Denotes final atomic publication.
85    Publishing,
86    /// Denotes successful terminal completion.
87    Complete,
88    /// Denotes terminal failure.
89    Failed,
90}
91
92impl TransferPhase {
93    /// States every phase one transfer passes through, in lifecycle order.
94    pub const LIFECYCLE: [Self; 9] = [
95        Self::Ready,
96        Self::Waiting,
97        Self::Rehearsing,
98        Self::Extracting,
99        Self::Downloading,
100        Self::Paused,
101        Self::Publishing,
102        Self::Complete,
103        Self::Failed,
104    ];
105
106    /// States whether a run is happening on the request's behalf while it is in this phase.
107    ///
108    /// A request that has not been asked for, and one that is over, are both unattended: nothing
109    /// is working on their behalf, and nothing has to be told they were removed.
110    pub const fn is_running(self) -> bool {
111        matches!(
112            self,
113            Self::Rehearsing
114                | Self::Extracting
115                | Self::Downloading
116                | Self::Paused
117                | Self::Publishing
118        )
119    }
120}
rsynko_manager/transfer.rs

rsynko_manager/
transfer.rs
