WIP

joaoantoniocardoso · Sep 15, 2024 · 692aa43 · 692aa43
1 parent 4dde7df
commit 692aa43
Show file tree

Hide file tree

Showing 19 changed files with 390 additions and 160 deletions.
diff --git a/src/drivers/fake.rs b/src/drivers/fake.rs
@@ -8,21 +8,21 @@ use tracing::*;
 use crate::{
     drivers::{Driver, DriverInfo},
     protocol::{read_all_messages, Protocol},
-    stats::driver::{DriverStats, DriverStatsInfo},
+    stats::driver::{AccumulatedDriverStats, AccumulatedDriverStatsProvider},
 };
 
 pub struct FakeSink {
     on_message_input: Callbacks<Arc<Protocol>>,
     print: bool,
-    stats: Arc<RwLock<DriverStatsInfo>>,
+    stats: Arc<RwLock<AccumulatedDriverStats>>,
 }
 
 impl FakeSink {
     pub fn builder() -> FakeSinkBuilder {
         FakeSinkBuilder(Self {
             on_message_input: Callbacks::new(),
             print: false,
-            stats: Arc::new(RwLock::new(DriverStatsInfo::default())),
+            stats: Arc::new(RwLock::new(AccumulatedDriverStats::default())),
         })
     }
 }
@@ -93,13 +93,13 @@ impl Driver for FakeSink {
 }
 
 #[async_trait::async_trait]
-impl DriverStats for FakeSink {
-    async fn stats(&self) -> DriverStatsInfo {
+impl AccumulatedDriverStatsProvider for FakeSink {
+    async fn stats(&self) -> AccumulatedDriverStats {
         self.stats.read().await.clone()
     }
 
     async fn reset_stats(&self) {
-        *self.stats.write().await = DriverStatsInfo {
+        *self.stats.write().await = AccumulatedDriverStats {
             input: None,
             output: None,
         }
@@ -146,15 +146,15 @@ impl DriverInfo for FakeSinkInfo {
 pub struct FakeSource {
     period: std::time::Duration,
     on_message_output: Callbacks<Arc<Protocol>>,
-    stats: Arc<RwLock<DriverStatsInfo>>,
+    stats: Arc<RwLock<AccumulatedDriverStats>>,
 }
 
 impl FakeSource {
     pub fn builder(period: std::time::Duration) -> FakeSourceBuilder {
         FakeSourceBuilder(Self {
             period,
             on_message_output: Callbacks::new(),
-            stats: Arc::new(RwLock::new(DriverStatsInfo::default())),
+            stats: Arc::new(RwLock::new(AccumulatedDriverStats::default())),
         })
     }
 }
@@ -248,13 +248,13 @@ impl Driver for FakeSource {
 }
 
 #[async_trait::async_trait]
-impl DriverStats for FakeSource {
-    async fn stats(&self) -> DriverStatsInfo {
+impl AccumulatedDriverStatsProvider for FakeSource {
+    async fn stats(&self) -> AccumulatedDriverStats {
         self.stats.read().await.clone()
     }
 
     async fn reset_stats(&self) {
-        *self.stats.write().await = DriverStatsInfo {
+        *self.stats.write().await = AccumulatedDriverStats {
             input: None,
             output: None,
         }

diff --git a/src/drivers/mod.rs b/src/drivers/mod.rs
@@ -12,7 +12,7 @@ use tokio::sync::broadcast;
 use tracing::*;
 use url::Url;
 
-use crate::{protocol::Protocol, stats::driver::DriverStats};
+use crate::{protocol::Protocol, stats::driver::AccumulatedDriverStatsProvider};
 
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
 pub enum Type {
@@ -36,7 +36,7 @@ pub struct DriverDescriptionLegacy {
 }
 
 #[async_trait::async_trait]
-pub trait Driver: Send + Sync + DriverStats {
+pub trait Driver: Send + Sync + AccumulatedDriverStatsProvider {
     async fn run(&self, hub_sender: broadcast::Sender<Arc<Protocol>>) -> Result<()>;
     fn info(&self) -> Box<dyn DriverInfo>;
 }
@@ -224,7 +224,7 @@ mod tests {
     use tokio::sync::RwLock;
     use tracing::*;
 
-    use crate::stats::driver::DriverStatsInfo;
+    use crate::stats::driver::AccumulatedDriverStats;
 
     use super::*;
 
@@ -244,15 +244,15 @@ mod tests {
     pub struct ExampleDriver {
         on_message_input: Callbacks<Arc<Protocol>>,
         on_message_output: Callbacks<Arc<Protocol>>,
-        stats: Arc<RwLock<DriverStatsInfo>>,
+        stats: Arc<RwLock<AccumulatedDriverStats>>,
     }
 
     impl ExampleDriver {
         pub fn new() -> ExampleDriverBuilder {
             ExampleDriverBuilder(Self {
                 on_message_input: Callbacks::new(),
                 on_message_output: Callbacks::new(),
-                stats: Arc::new(RwLock::new(DriverStatsInfo::default())),
+                stats: Arc::new(RwLock::new(AccumulatedDriverStats::default())),
             })
         }
     }
@@ -306,13 +306,13 @@ mod tests {
     }
 
     #[async_trait::async_trait]
-    impl DriverStats for ExampleDriver {
-        async fn stats(&self) -> DriverStatsInfo {
+    impl AccumulatedDriverStatsProvider for ExampleDriver {
+        async fn stats(&self) -> AccumulatedDriverStats {
             self.stats.read().await.clone()
         }
 
         async fn reset_stats(&self) {
-            *self.stats.write().await = DriverStatsInfo {
+            *self.stats.write().await = AccumulatedDriverStats {
                 input: None,
                 output: None,
             }

diff --git a/src/drivers/serial/mod.rs b/src/drivers/serial/mod.rs
@@ -12,15 +12,15 @@ use tracing::*;
 use crate::{
     drivers::{Driver, DriverInfo},
     protocol::{read_all_messages, Protocol},
-    stats::driver::{DriverStats, DriverStatsInfo},
+    stats::driver::{AccumulatedDriverStats, AccumulatedDriverStatsProvider},
 };
 
 pub struct Serial {
     pub port_name: String,
     pub baud_rate: u32,
     on_message_input: Callbacks<Arc<Protocol>>,
     on_message_output: Callbacks<Arc<Protocol>>,
-    stats: Arc<RwLock<DriverStatsInfo>>,
+    stats: Arc<RwLock<AccumulatedDriverStats>>,
 }
 
 pub struct SerialBuilder(Serial);
@@ -55,7 +55,7 @@ impl Serial {
             baud_rate,
             on_message_input: Callbacks::new(),
             on_message_output: Callbacks::new(),
-            stats: Arc::new(RwLock::new(DriverStatsInfo::default())),
+            stats: Arc::new(RwLock::new(AccumulatedDriverStats::default())),
         })
     }
 
@@ -179,13 +179,13 @@ impl Driver for Serial {
 }
 
 #[async_trait::async_trait]
-impl DriverStats for Serial {
-    async fn stats(&self) -> DriverStatsInfo {
+impl AccumulatedDriverStatsProvider for Serial {
+    async fn stats(&self) -> AccumulatedDriverStats {
         self.stats.read().await.clone()
     }
 
     async fn reset_stats(&self) {
-        *self.stats.write().await = DriverStatsInfo {
+        *self.stats.write().await = AccumulatedDriverStats {
             input: None,
             output: None,
         }

diff --git a/src/drivers/tcp/client.rs b/src/drivers/tcp/client.rs
@@ -14,14 +14,14 @@ use crate::{
         Driver, DriverInfo,
     },
     protocol::Protocol,
-    stats::driver::{DriverStats, DriverStatsInfo},
+    stats::driver::{AccumulatedDriverStatsProvider, AccumulatedDriverStats},
 };
 
 pub struct TcpClient {
     pub remote_addr: String,
     on_message_input: Callbacks<Arc<Protocol>>,
     on_message_output: Callbacks<Arc<Protocol>>,
-    stats: Arc<RwLock<DriverStatsInfo>>,
+    stats: Arc<RwLock<AccumulatedDriverStats>>,
 }
 
 pub struct TcpClientBuilder(TcpClient);
@@ -55,7 +55,7 @@ impl TcpClient {
             remote_addr: remote_addr.to_string(),
             on_message_input: Callbacks::new(),
             on_message_output: Callbacks::new(),
-            stats: Arc::new(RwLock::new(DriverStatsInfo::default())),
+            stats: Arc::new(RwLock::new(AccumulatedDriverStats::default())),
         })
     }
 }
@@ -105,13 +105,13 @@ impl Driver for TcpClient {
 }
 
 #[async_trait::async_trait]
-impl DriverStats for TcpClient {
-    async fn stats(&self) -> DriverStatsInfo {
+impl AccumulatedDriverStatsProvider for TcpClient {
+    async fn stats(&self) -> AccumulatedDriverStats {
         self.stats.read().await.clone()
     }
 
     async fn reset_stats(&self) {
-        *self.stats.write().await = DriverStatsInfo {
+        *self.stats.write().await = AccumulatedDriverStats {
             input: None,
             output: None,
         }

diff --git a/src/drivers/tcp/mod.rs b/src/drivers/tcp/mod.rs
@@ -11,7 +11,7 @@ use tracing::*;
 
 use crate::{
     protocol::{read_all_messages, Protocol},
-    stats::driver::DriverStatsInfo,
+    stats::driver::AccumulatedDriverStats,
 };
 
 pub mod client;
@@ -24,7 +24,7 @@ async fn tcp_receive_task(
     remote_addr: &str,
     hub_sender: Arc<broadcast::Sender<Arc<Protocol>>>,
     on_message_input: &Callbacks<Arc<Protocol>>,
-    stats: &Arc<RwLock<DriverStatsInfo>>,
+    stats: &Arc<RwLock<AccumulatedDriverStats>>,
 ) -> Result<()> {
     let mut buf = Vec::with_capacity(1024);
 
@@ -67,7 +67,7 @@ async fn tcp_send_task(
     remote_addr: &str,
     mut hub_receiver: broadcast::Receiver<Arc<Protocol>>,
     on_message_output: &Callbacks<Arc<Protocol>>,
-    stats: &Arc<RwLock<DriverStatsInfo>>,
+    stats: &Arc<RwLock<AccumulatedDriverStats>>,
 ) -> Result<()> {
     loop {
         let message = match hub_receiver.recv().await {

diff --git a/src/drivers/tcp/server.rs b/src/drivers/tcp/server.rs
@@ -14,15 +14,15 @@ use crate::{
         Driver, DriverInfo,
     },
     protocol::Protocol,
-    stats::driver::{DriverStats, DriverStatsInfo},
+    stats::driver::{AccumulatedDriverStatsProvider, AccumulatedDriverStats},
 };
 
 #[derive(Clone)]
 pub struct TcpServer {
     pub local_addr: String,
     on_message_input: Callbacks<Arc<Protocol>>,
     on_message_output: Callbacks<Arc<Protocol>>,
-    stats: Arc<RwLock<DriverStatsInfo>>,
+    stats: Arc<RwLock<AccumulatedDriverStats>>,
 }
 
 pub struct TcpServerBuilder(TcpServer);
@@ -56,7 +56,7 @@ impl TcpServer {
             local_addr: local_addr.to_string(),
             on_message_input: Callbacks::new(),
             on_message_output: Callbacks::new(),
-            stats: Arc::new(RwLock::new(DriverStatsInfo::default())),
+            stats: Arc::new(RwLock::new(AccumulatedDriverStats::default())),
         })
     }
 
@@ -71,7 +71,7 @@ impl TcpServer {
         hub_sender: Arc<broadcast::Sender<Arc<Protocol>>>,
         on_message_input: Callbacks<Arc<Protocol>>,
         on_message_output: Callbacks<Arc<Protocol>>,
-        stats: Arc<RwLock<DriverStatsInfo>>,
+        stats: Arc<RwLock<AccumulatedDriverStats>>,
     ) -> Result<()> {
         let hub_receiver = hub_sender.subscribe();
 
@@ -132,13 +132,13 @@ impl Driver for TcpServer {
 }
 
 #[async_trait::async_trait]
-impl DriverStats for TcpServer {
-    async fn stats(&self) -> DriverStatsInfo {
+impl AccumulatedDriverStatsProvider for TcpServer {
+    async fn stats(&self) -> AccumulatedDriverStats {
         self.stats.read().await.clone()
     }
 
     async fn reset_stats(&self) {
-        *self.stats.write().await = DriverStatsInfo {
+        *self.stats.write().await = AccumulatedDriverStats {
             input: None,
             output: None,
         }

diff --git a/src/drivers/tlog/reader.rs b/src/drivers/tlog/reader.rs
@@ -10,13 +10,13 @@ use tracing::*;
 use crate::{
     drivers::{Driver, DriverInfo},
     protocol::Protocol,
-    stats::driver::{DriverStats, DriverStatsInfo},
+    stats::driver::{AccumulatedDriverStatsProvider, AccumulatedDriverStats},
 };
 
 pub struct TlogReader {
     pub path: PathBuf,
     on_message_input: Callbacks<Arc<Protocol>>,
-    stats: Arc<RwLock<DriverStatsInfo>>,
+    stats: Arc<RwLock<AccumulatedDriverStats>>,
 }
 
 pub struct TlogReaderBuilder(TlogReader);
@@ -41,7 +41,7 @@ impl TlogReader {
         TlogReaderBuilder(Self {
             path,
             on_message_input: Callbacks::new(),
-            stats: Arc::new(RwLock::new(DriverStatsInfo::default())),
+            stats: Arc::new(RwLock::new(AccumulatedDriverStats::default())),
         })
     }
 
@@ -141,13 +141,13 @@ impl Driver for TlogReader {
 }
 
 #[async_trait::async_trait]
-impl DriverStats for TlogReader {
-    async fn stats(&self) -> DriverStatsInfo {
+impl AccumulatedDriverStatsProvider for TlogReader {
+    async fn stats(&self) -> AccumulatedDriverStats {
         self.stats.read().await.clone()
     }
 
     async fn reset_stats(&self) {
-        *self.stats.write().await = DriverStatsInfo {
+        *self.stats.write().await = AccumulatedDriverStats {
             input: None,
             output: None,
         }

diff --git a/src/drivers/tlog/writer.rs b/src/drivers/tlog/writer.rs
@@ -11,13 +11,13 @@ use tracing::*;
 use crate::{
     drivers::{Driver, DriverInfo},
     protocol::Protocol,
-    stats::driver::{DriverStats, DriverStatsInfo},
+    stats::driver::{AccumulatedDriverStatsProvider, AccumulatedDriverStats},
 };
 
 pub struct TlogWriter {
     pub path: PathBuf,
     on_message_output: Callbacks<Arc<Protocol>>,
-    stats: Arc<RwLock<DriverStatsInfo>>,
+    stats: Arc<RwLock<AccumulatedDriverStats>>,
 }
 
 pub struct TlogWriterBuilder(TlogWriter);
@@ -42,7 +42,7 @@ impl TlogWriter {
         TlogWriterBuilder(Self {
             path,
             on_message_output: Callbacks::new(),
-            stats: Arc::new(RwLock::new(DriverStatsInfo::default())),
+            stats: Arc::new(RwLock::new(AccumulatedDriverStats::default())),
         })
     }
 
@@ -109,13 +109,13 @@ impl Driver for TlogWriter {
 }
 
 #[async_trait::async_trait]
-impl DriverStats for TlogWriter {
-    async fn stats(&self) -> DriverStatsInfo {
+impl AccumulatedDriverStatsProvider for TlogWriter {
+    async fn stats(&self) -> AccumulatedDriverStats {
         self.stats.read().await.clone()
     }
 
     async fn reset_stats(&self) {
-        *self.stats.write().await = DriverStatsInfo {
+        *self.stats.write().await = AccumulatedDriverStats {
             input: None,
             output: None,
         }