refactor: use an unbounded mpsc tokio channel for measurements

src/measurement/icmp.rs

@@ -5,7 +5,7 @@ use std::{
     time::{Duration, Instant, SystemTime},
 };
 
-use flume::{Receiver, Sender};
+use flume::Receiver;
 use icmp_socket2::{
     AsyncIcmpSocket, IcmpSocket4, Icmpv4Message, Icmpv4Packet,
     packet::{IcmpPacketBuildError, WithEchoRequest, WithTimestampRequest},
@@ -13,6 +13,7 @@ use icmp_socket2::{
 };
 use log::debug;
 use thiserror::Error;
+use tokio::sync::mpsc::UnboundedSender;
 
 use crate::{
     measurement::model::{
@@ -104,7 +105,7 @@ pub struct IcmpEngine {
     origin: Instant,
 
     binding_rx: Receiver<Vec<IcmpBinding>>,
-    observation_tx: Sender<MeasurementEvent>,
+    observation_tx: UnboundedSender<MeasurementEvent>,
 }
 
 async fn wait_for_deadline(deadline: Option<Instant>) {
@@ -123,7 +124,7 @@ impl IcmpEngine {
     pub fn new(
         origin: Instant,
         #[allow(unused)] settings: &NetworkSettings,
-        observation_tx: Sender<MeasurementEvent>,
+        observation_tx: UnboundedSender<MeasurementEvent>,
         binding_rx: Receiver<Vec<IcmpBinding>>,
     ) -> Result<Self, IcmpError> {
         #[allow(unused_mut)]
@@ -420,12 +421,11 @@ impl IcmpEngine {
 
         for probe in expired {
             self.observation_tx
-                .send_async(MeasurementEvent::Loss(MeasurementLoss {
+                .send(MeasurementEvent::Loss(MeasurementLoss {
                     stream: probe.stream,
                     started_at: probe.sent_at,
                     detected_at: now,
                 }))
-                .await
                 .map_err(|_| IcmpError::EventChannelClosed)?;
         }
 
@@ -468,8 +468,7 @@ impl IcmpEngine {
                     ) {
                         Ok(observation) => {
                             self.observation_tx
-                                .send_async(MeasurementEvent::Observation(observation))
-                                .await
+                                .send(MeasurementEvent::Observation(observation))
                                 .map_err(|_| IcmpError::EventChannelClosed)?;
                         }
 

src/measurement/irtt.rs

@@ -1,6 +1,6 @@
 use std::{collections::HashMap, net::SocketAddr};
 
-use flume::{Receiver, Sender};
+use flume::Receiver;
 use irtt_client::{
     ClientConfig, ClientEvent, NegotiationPolicy, OpenPolicy,
     managed::{
@@ -12,7 +12,7 @@ use irtt_client::{
 };
 use log::{debug, trace, warn};
 use thiserror::Error;
-use tokio::sync::broadcast::error::RecvError;
+use tokio::sync::{broadcast::error::RecvError, mpsc::UnboundedSender};
 
 use crate::SHUTDOWN;
 use crate::measurement::model::{
@@ -70,14 +70,14 @@ pub struct IrttEngine {
     targets: Vec<ManagedTargetConfig>,
 
     binding_rx: Receiver<Vec<IrttBinding>>,
-    observation_tx: Sender<MeasurementEvent>,
+    observation_tx: UnboundedSender<MeasurementEvent>,
 }
 
 impl IrttEngine {
     pub fn new(
         interval: std::time::Duration,
         settings: &NetworkSettings,
-        observation_tx: Sender<MeasurementEvent>,
+        observation_tx: UnboundedSender<MeasurementEvent>,
         binding_rx: Receiver<Vec<IrttBinding>>,
     ) -> Result<(ManagedClientTask, Self), IrttError> {
         let config = managed_client_config(interval, settings);
@@ -273,8 +273,7 @@ impl IrttEngine {
                                     };
 
                                     self.observation_tx
-                                        .send_async(MeasurementEvent::Observation(observation))
-                                        .await
+                                        .send(MeasurementEvent::Observation(observation))
                                         .map_err(|_| IrttError::EventChannelClosed)?;
                                 }
 
@@ -294,8 +293,7 @@ impl IrttEngine {
                                     };
 
                                     self.observation_tx
-                                        .send_async(MeasurementEvent::Loss(loss))
-                                        .await
+                                        .send(MeasurementEvent::Loss(loss))
                                         .map_err(|_| IrttError::EventChannelClosed)?;
                                 }