add disabled heartbeat option on diode-receive side, add doc and log

messages

src/bin/diode-receive.rs

@@ -20,7 +20,7 @@ struct Config {
     flush_timeout: time::Duration,
     nb_decoding_threads: u8,
     to: ClientConfig,
-    heartbeat: time::Duration,
+    heartbeat: Option<time::Duration>,
 }
 
 enum ClientConfig {
@@ -118,7 +118,7 @@ fn command_args() -> Config {
                 .value_name("nb_seconds")
                 .default_value("10")
                 .value_parser(clap::value_parser!(u16))
-                .help("Maximum duration expected between heartbeat messages"),
+                .help("Maximum duration expected between heartbeat messages, 0 to disable"),
         )
         .get_matches();
 
@@ -141,8 +141,10 @@ fn command_args() -> Config {
         .get_one::<String>("to_unix")
         .map(|s| path::PathBuf::from_str(s).expect("to_unix must point to a valid path"));
 
-    let heartbeat =
-        time::Duration::from_secs(*args.get_one::<u16>("heartbeat").expect("default") as u64);
+    let heartbeat = {
+        let hb = *args.get_one::<u16>("heartbeat").expect("default") as u64;
+        (hb != 0).then(|| time::Duration::from_secs(hb))
+    };
 
     let to = if let Some(to_tcp) = to_tcp {
         ClientConfig::Tcp(to_tcp)

src/bin/diode-send.rs

@@ -21,7 +21,7 @@ struct Config {
     to_bind: net::SocketAddr,
     to_udp: net::SocketAddr,
     to_udp_mtu: u16,
-    heartbeat: time::Duration,
+    heartbeat: Option<time::Duration>,
 }
 
 fn command_args() -> Config {
@@ -109,7 +109,7 @@ fn command_args() -> Config {
                 .value_name("nb_seconds")
                 .default_value("5")
                 .value_parser(clap::value_parser!(u16))
-                .help("Duration between two emitted heartbeat messages"),
+                .help("Duration between two emitted heartbeat messages, 0 to disable"),
         )
         .get_matches();
 
@@ -133,8 +133,10 @@ fn command_args() -> Config {
     let to_udp = net::SocketAddr::from_str(args.get_one::<String>("to_udp").expect("default"))
         .expect("invalid to_udp parameter");
     let to_udp_mtu = *args.get_one::<u16>("to_udp_mtu").expect("default");
-    let heartbeat =
-        time::Duration::from_secs(*args.get_one::<u16>("heartbeat").expect("default") as u64);
+    let heartbeat = {
+        let hb = *args.get_one::<u16>("heartbeat").expect("default") as u64;
+        (hb != 0).then(|| time::Duration::from_secs(hb))
+    };
 
     Config {
         from_tcp,

src/receive/dispatch.rs

@@ -21,20 +21,21 @@ pub(crate) fn start<F>(receiver: &receive::Receiver<F>) -> Result<(), receive::E
     let mut last_heartbeat = time::Instant::now();
 
     loop {
-        let message = match receiver
-            .for_dispatch
-            .recv_timeout(receiver.config.heartbeat_interval)
-        {
-            Err(crossbeam_channel::RecvTimeoutError::Timeout) => {
-                if last_heartbeat.elapsed() > receiver.config.heartbeat_interval {
-                    log::warn!(
-                        "no heartbeat message received during the last {} second(s)",
-                        receiver.config.heartbeat_interval.as_secs()
-                    );
+        let message = if let Some(hb_interval) = receiver.config.heartbeat_interval {
+            match receiver.for_dispatch.recv_timeout(hb_interval) {
+                Err(crossbeam_channel::RecvTimeoutError::Timeout) => {
+                    if last_heartbeat.elapsed() > hb_interval {
+                        log::warn!(
+                            "no heartbeat message received during the last {} second(s)",
+                            hb_interval.as_secs()
+                        );
+                    }
+                    continue;
                 }
-                continue;
+                other => other?,
             }
-            other => other?,
+        } else {
+            receiver.for_dispatch.recv()?
         };
 
         log::trace!("received {message}");

src/receive/mod.rs

@@ -40,7 +40,7 @@ pub struct Config {
     pub repair_block_size: u32,
     pub flush_timeout: time::Duration,
     pub nb_decoding_threads: u8,
-    pub heartbeat_interval: time::Duration,
+    pub heartbeat_interval: Option<time::Duration>,
 }
 
 impl Config {
@@ -252,6 +252,15 @@ where
             self.config.flush_timeout.as_millis()
         );
 
+        if let Some(hb_interval) = self.config.heartbeat_interval {
+            log::info!(
+                "heartbeat interval is set to {} seconds",
+                hb_interval.as_secs()
+            );
+        } else {
+            log::info!("heartbeat is disabled");
+        }
+
         for i in 0..self.config.nb_clients {
             thread::Builder::new()
                 .name(format!("client_{i}"))

src/send/heartbeat.rs

@@ -3,7 +3,8 @@
 use crate::{protocol, send};
 
 pub(crate) fn start<C>(sender: &send::Sender<C>) -> Result<(), send::Error> {
-    let alarm = crossbeam_channel::tick(sender.config.hearbeat_interval);
+    let alarm =
+        crossbeam_channel::tick(sender.config.hearbeat_interval.expect("heartbeat enabled"));
 
     loop {
         sender.to_encoding.send(protocol::Message::new(

src/send/mod.rs

@@ -39,7 +39,7 @@ pub struct Config {
     pub encoding_block_size: u64,
     pub repair_block_size: u32,
     pub nb_encoding_threads: u8,
-    pub hearbeat_interval: time::Duration,
+    pub hearbeat_interval: Option<time::Duration>,
     pub to_bind: net::SocketAddr,
     pub to_udp: net::SocketAddr,
     pub to_mtu: u16,
@@ -211,10 +211,16 @@ where
                 .spawn_scoped(scope, || encoding::start(self))?;
         }
 
-        if !self.config.hearbeat_interval.is_zero() {
+        if let Some(hb_interval) = self.config.hearbeat_interval {
+            log::info!(
+                "heartbeat message will be sent every {} seconds",
+                hb_interval.as_secs()
+            );
             thread::Builder::new()
                 .name("heartbeat".into())
                 .spawn_scoped(scope, || heartbeat::start(self))?;
+        } else {
+            log::info!("heartbeat is disabled");
         }
 
         for i in 0..self.config.nb_clients {