use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Arc, OnceLock};
use std::time::{Duration, Instant};
use super::ActivitySignal;
static ACTIVITY_CLOCK_START: OnceLock<Instant> = OnceLock::new();
fn activity_clock_start() -> Instant {
*ACTIVITY_CLOCK_START.get_or_init(Instant::now)
}
fn current_activity_ticks() -> u64 {
Instant::now()
.duration_since(activity_clock_start())
.as_nanos()
.min(u128::from(u64::MAX)) as u64
}
fn instant_from_activity_ticks(ticks: u64) -> Instant {
activity_clock_start()
.checked_add(Duration::from_nanos(ticks))
.unwrap_or_else(activity_clock_start)
}
pub struct AtomicProgress {
completed_length: AtomicU64,
total_length: AtomicU64,
upload_length: AtomicU64,
download_payload_bytes: AtomicU64,
download_speed: AtomicU64,
upload_speed: AtomicU64,
last_network_activity: AtomicU64,
download_rate_signal: Arc<tokio::sync::Notify>,
activity_signal: OnceLock<Arc<ActivitySignal>>,
}
impl Default for AtomicProgress {
fn default() -> Self {
Self::new()
}
}
impl AtomicProgress {
pub fn new() -> Self {
let now = current_activity_ticks();
Self {
completed_length: AtomicU64::new(0),
total_length: AtomicU64::new(0),
upload_length: AtomicU64::new(0),
download_payload_bytes: AtomicU64::new(0),
download_speed: AtomicU64::new(0),
upload_speed: AtomicU64::new(0),
last_network_activity: AtomicU64::new(now),
download_rate_signal: Arc::new(tokio::sync::Notify::new()),
activity_signal: OnceLock::new(),
}
}
pub(crate) fn attach_activity_signal(&self, signal: Arc<ActivitySignal>) {
let _ = self.activity_signal.set(signal);
}
fn notify_activity(&self) {
if let Some(signal) = self.activity_signal.get() {
signal.notify();
}
}
pub(crate) fn reset_network_activity(&self) {
self.last_network_activity
.store(current_activity_ticks(), Ordering::Release);
}
pub(crate) fn record_network_activity(&self) {
self.last_network_activity
.fetch_max(current_activity_ticks(), Ordering::AcqRel);
}
pub(crate) fn download_rate_signal(&self) -> Arc<tokio::sync::Notify> {
Arc::clone(&self.download_rate_signal)
}
pub(crate) fn record_download_payload(&self, bytes: u64) {
if bytes == 0 {
return;
}
self.download_payload_bytes
.fetch_add(bytes, Ordering::Relaxed);
self.record_network_activity();
self.download_rate_signal.notify_one();
}
pub(crate) fn take_download_payload_bytes(&self) -> u64 {
self.download_payload_bytes.swap(0, Ordering::AcqRel)
}
pub(crate) fn last_network_activity(&self) -> Instant {
instant_from_activity_ticks(self.last_network_activity.load(Ordering::Acquire))
}
pub fn completed_length(&self) -> u64 {
self.completed_length.load(Ordering::Relaxed)
}
pub fn set_completed_length(&self, v: u64) {
if self.completed_length.swap(v, Ordering::Relaxed) != v {
self.notify_activity();
}
}
pub fn total_length(&self) -> u64 {
self.total_length.load(Ordering::Relaxed)
}
pub fn set_total_length(&self, v: u64) {
if self.total_length.swap(v, Ordering::Relaxed) != v {
self.notify_activity();
}
}
pub fn download_speed(&self) -> u64 {
self.download_speed.load(Ordering::Relaxed)
}
pub fn set_download_speed(&self, v: u64) {
if self.download_speed.swap(v, Ordering::Relaxed) != v {
self.notify_activity();
}
}
pub fn upload_speed(&self) -> u64 {
self.upload_speed.load(Ordering::Relaxed)
}
pub fn set_upload_speed(&self, v: u64) {
if self.upload_speed.swap(v, Ordering::Relaxed) != v {
self.notify_activity();
}
}
pub fn upload_length(&self) -> u64 {
self.upload_length.load(Ordering::Relaxed)
}
pub fn set_upload_length(&self, v: u64) {
if self.upload_length.swap(v, Ordering::Relaxed) != v {
self.notify_activity();
}
}
pub fn add_upload_length(&self, bytes: u64) {
if bytes != 0 {
self.upload_length.fetch_add(bytes, Ordering::Relaxed);
self.notify_activity();
}
}
}