use std::sync::atomic::{AtomicU64, AtomicUsize, Ordering};
#[derive(Debug, Default)]
pub struct Stats {
pub directories_deleted: AtomicUsize,
pub files_deleted: AtomicUsize,
pub bytes_freed: AtomicU64,
pub errors: AtomicUsize,
}
impl Stats {
pub fn new() -> Self {
Self::default()
}
#[cfg(test)]
#[inline]
pub fn add_directory(&self) {
self.add_directories(1);
}
#[inline]
pub fn add_directories(&self, count: usize) {
let _ =
self.directories_deleted
.fetch_update(Ordering::Relaxed, Ordering::Relaxed, |value| {
Some(value.saturating_add(count))
});
}
#[cfg(test)]
#[inline]
pub fn add_file(&self) {
self.add_files(1);
}
#[inline]
pub fn add_files(&self, count: usize) {
let _ = self
.files_deleted
.fetch_update(Ordering::Relaxed, Ordering::Relaxed, |value| {
Some(value.saturating_add(count))
});
}
#[inline]
pub fn add_bytes(&self, bytes: u64) {
let _ = self
.bytes_freed
.fetch_update(Ordering::Relaxed, Ordering::Relaxed, |value| {
Some(value.saturating_add(bytes))
});
}
#[cfg(test)]
#[inline]
pub fn add_error(&self) {
self.add_errors(1);
}
#[inline]
pub fn add_errors(&self, count: usize) {
let _ = self
.errors
.fetch_update(Ordering::Relaxed, Ordering::Relaxed, |value| {
Some(value.saturating_add(count))
});
}
pub fn add_batch(&self, directories: usize, files: usize, bytes: u64, errors: usize) {
self.add_directories(directories);
self.add_files(files);
self.add_bytes(bytes);
self.add_errors(errors);
}
pub fn directories(&self) -> usize {
self.directories_deleted.load(Ordering::Relaxed)
}
pub fn files(&self) -> usize {
self.files_deleted.load(Ordering::Relaxed)
}
pub fn bytes(&self) -> u64 {
self.bytes_freed.load(Ordering::Relaxed)
}
pub fn error_count(&self) -> usize {
self.errors.load(Ordering::Relaxed)
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::Arc;
#[test]
fn counters_start_at_zero_and_accumulate() {
let stats = Stats::new();
assert_eq!(
(
stats.directories(),
stats.files(),
stats.bytes(),
stats.error_count()
),
(0, 0, 0, 0)
);
stats.add_directory();
stats.add_file();
stats.add_files(3);
stats.add_bytes(42);
stats.add_bytes(8);
stats.add_error();
assert_eq!(
(
stats.directories(),
stats.files(),
stats.bytes(),
stats.error_count()
),
(1, 4, 50, 1)
);
}
#[test]
fn counters_are_thread_safe() {
let stats = Arc::new(Stats::new());
let threads: Vec<_> = (0..8)
.map(|_| {
let stats = Arc::clone(&stats);
std::thread::spawn(move || {
for _ in 0..100 {
stats.add_file();
stats.add_bytes(2);
}
})
})
.collect();
for thread in threads {
thread.join().unwrap();
}
assert_eq!(stats.files(), 800);
assert_eq!(stats.bytes(), 1600);
}
}