cancellation

src/sources/chrony.rs

@@ -5,7 +5,9 @@ use async_trait::async_trait;
 use chrony_candm::reply::{self, ReplyBody, SourceMode};
 use chrony_candm::request::{self, RequestBody};
 use chrony_candm::{ClientOptions, blocking_query};
-use tokio::join;
+use futures::future::join;
+use tokio::{join, select};
+use tokio_util::sync::CancellationToken;
 use tracing::{info, warn};
 
 use crate::{
@@ -297,38 +299,33 @@ impl ChimemonSource for ChronyClient {
             config,
         }
     }
-    async fn run(self, chan: ChimemonSourceChannel) {
+    async fn run(self, chan: ChimemonSourceChannel, cancel: CancellationToken) {
         info!("Chrony task started");
 
         let mut t_interval = tokio::time::interval(self.config.tracking_interval);
         let mut s_interval = tokio::time::interval(self.config.sources_interval);
-
-        let t_future = async {
-            let lchan = chan.clone();
-            loop {
-                t_interval.tick().await;
-
-                match self.tracking_poll(&lchan).await {
-                    Ok(_) => (),
-                    Err(e) => {
-                        warn!("Error in chrony task: {}", e.to_string());
+        loop {
+            select! {
+                _ = cancel.cancelled() => {
+                    return
+                },
+                _ = t_interval.tick() => {
+                    match self.tracking_poll(&chan).await {
+                        Ok(_) => (),
+                        Err(e) => {
+                            warn!("Error in chrony task: {}", e.to_string());
+                        }
+                    }
+                },
+                _ = s_interval.tick() => {
+                    match self.sources_poll(&chan).await {
+                        Ok(_) => (),
+                        Err(e) => {
+                            warn!("Error in chrony task: {}", e.to_string());
+                        }
                     }
                 }
             }
-        };
-        let s_future = async {
-            let lchan = chan.clone();
-            loop {
-                s_interval.tick().await;
-
-                match self.sources_poll(&lchan).await {
-                    Ok(_) => (),
-                    Err(e) => {
-                        warn!("Error in chrony task: {}", e.to_string());
-                    }
-                }
-            }
-        };
-        join!(t_future, s_future);
+        }
     }
 }