1use std::sync::atomic::{AtomicU64, AtomicUsize, Ordering};
4
5#[derive(Debug, Default)]
8pub struct Stats {
9 pub directories_deleted: AtomicUsize,
10 pub files_deleted: AtomicUsize,
11 pub bytes_freed: AtomicU64,
12 pub errors: AtomicUsize,
13}
14
15impl Stats {
16 pub fn new() -> Self {
17 Self::default()
18 }
19
20 #[cfg(test)]
21 #[inline]
22 pub fn add_directory(&self) {
23 self.add_directories(1);
24 }
25
26 #[inline]
27 pub fn add_directories(&self, count: usize) {
28 let _ =
29 self.directories_deleted
30 .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |value| {
31 Some(value.saturating_add(count))
32 });
33 }
34
35 #[cfg(test)]
36 #[inline]
37 pub fn add_file(&self) {
38 self.add_files(1);
39 }
40
41 #[inline]
42 pub fn add_files(&self, count: usize) {
43 let _ = self
44 .files_deleted
45 .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |value| {
46 Some(value.saturating_add(count))
47 });
48 }
49
50 #[inline]
51 pub fn add_bytes(&self, bytes: u64) {
52 let _ = self
53 .bytes_freed
54 .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |value| {
55 Some(value.saturating_add(bytes))
56 });
57 }
58
59 #[cfg(test)]
60 #[inline]
61 pub fn add_error(&self) {
62 self.add_errors(1);
63 }
64
65 #[inline]
66 pub fn add_errors(&self, count: usize) {
67 let _ = self
68 .errors
69 .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |value| {
70 Some(value.saturating_add(count))
71 });
72 }
73
74 pub fn add_batch(&self, directories: usize, files: usize, bytes: u64, errors: usize) {
75 self.add_directories(directories);
76 self.add_files(files);
77 self.add_bytes(bytes);
78 self.add_errors(errors);
79 }
80
81 pub fn directories(&self) -> usize {
82 self.directories_deleted.load(Ordering::Relaxed)
83 }
84
85 pub fn files(&self) -> usize {
86 self.files_deleted.load(Ordering::Relaxed)
87 }
88
89 pub fn bytes(&self) -> u64 {
90 self.bytes_freed.load(Ordering::Relaxed)
91 }
92
93 pub fn error_count(&self) -> usize {
94 self.errors.load(Ordering::Relaxed)
95 }
96}
97
98#[cfg(test)]
99mod tests {
100 use super::*;
101 use std::sync::Arc;
102
103 #[test]
104 fn counters_start_at_zero_and_accumulate() {
105 let stats = Stats::new();
106 assert_eq!(
107 (
108 stats.directories(),
109 stats.files(),
110 stats.bytes(),
111 stats.error_count()
112 ),
113 (0, 0, 0, 0)
114 );
115 stats.add_directory();
116 stats.add_file();
117 stats.add_files(3);
118 stats.add_bytes(42);
119 stats.add_bytes(8);
120 stats.add_error();
121 assert_eq!(
122 (
123 stats.directories(),
124 stats.files(),
125 stats.bytes(),
126 stats.error_count()
127 ),
128 (1, 4, 50, 1)
129 );
130 }
131
132 #[test]
133 fn counters_are_thread_safe() {
134 let stats = Arc::new(Stats::new());
135 let threads: Vec<_> = (0..8)
136 .map(|_| {
137 let stats = Arc::clone(&stats);
138 std::thread::spawn(move || {
139 for _ in 0..100 {
140 stats.add_file();
141 stats.add_bytes(2);
142 }
143 })
144 })
145 .collect();
146 for thread in threads {
147 thread.join().unwrap();
148 }
149 assert_eq!(stats.files(), 800);
150 assert_eq!(stats.bytes(), 1600);
151 }
152}