[Monitor] Use eyre for error reporting

Author: rnijveld

Cargo.lock

@@ -16,6 +16,7 @@ __internal-fuzz = []
 [dependencies]
 aead.workspace = true
 aes-siv.workspace = true
+eyre = { workspace = true }
 nts-pool-shared.workspace = true
 pool-nts.workspace = true
 rand.workspace = true

nts-pool-monitor/Cargo.toml

@@ -28,6 +28,7 @@ use std::{
     sync::{Arc, RwLock},
 };
 
+use eyre::Context;
 use nts_pool_shared::{ProbeControlCommand, ProbeResult};
 use serde::Serialize;
 use tokio::{
@@ -55,7 +56,7 @@ trait ProbeExecutor {
     fn run_probe(
         self: Arc<Self>,
         timesource: (IpVersion, String),
-    ) -> impl Future<Output = Result<Self::Output, std::io::Error>> + Send;
+    ) -> impl Future<Output = Result<Self::Output, eyre::Error>> + Send;
 }
 
 impl ProbeExecutor for Probe {
@@ -78,7 +79,7 @@ impl ProbeExecutor for Probe {
     async fn run_probe(
         self: Arc<Self>,
         timesource: (IpVersion, String),
-    ) -> Result<Self::Output, std::io::Error> {
+    ) -> Result<Self::Output, eyre::Error> {
         self.probe(timesource.1, timesource.0).await
     }
 }
@@ -87,7 +88,7 @@ impl ProbeExecutor for Probe {
 trait ManagementRequestor {
     fn get_command(
         config: &ProbeControlConfig,
-    ) -> impl Future<Output = Result<ProbeControlCommand, std::io::Error>> + Send;
+    ) -> impl Future<Output = Result<ProbeControlCommand, eyre::Error>> + Send;
 }
 
 async fn run_probing_inner<
@@ -104,7 +105,7 @@ async fn run_probing_inner<
     let command = match M::get_command(&config).await {
         Ok(command) => command,
         Err(e) => {
-            error!("Could not fetch initial command: {}", e);
+            error!("Could not fetch initial command: {:?}", e);
             std::process::exit(crate::exitcode::SOFTWARE);
         }
     };
@@ -311,16 +312,17 @@ async fn run_result_reporter<T: Send + Serialize + 'static>(
 struct ReqwestManagementRequestor;
 
 impl ManagementRequestor for ReqwestManagementRequestor {
-    async fn get_command(
-        config: &ProbeControlConfig,
-    ) -> Result<ProbeControlCommand, std::io::Error> {
+    async fn get_command(config: &ProbeControlConfig) -> Result<ProbeControlCommand, eyre::Error> {
         let result = reqwest::Client::new()
             .get(&config.management_interface)
             .bearer_auth(&config.authorization_key)
             .send()
             .await
-            .map_err(std::io::Error::other)?;
-        result.json().await.map_err(std::io::Error::other)
+            .wrap_err("Failed to send probe request/get probe response")?;
+        result
+            .json()
+            .await
+            .wrap_err("Could not convert JSON response to probe command")
     }
 }
 
@@ -371,7 +373,7 @@ mod tests {
         async fn run_probe(
             self: Arc<Self>,
             timesource: (IpVersion, String),
-        ) -> Result<Self::Output, std::io::Error> {
+        ) -> Result<Self::Output, eyre::Error> {
             Ok(timesource)
         }
     }
@@ -497,7 +499,7 @@ mod tests {
         impl ManagementRequestor for BasicCommandRequestor {
             async fn get_command(
                 _config: &ProbeControlConfig,
-            ) -> Result<ProbeControlCommand, std::io::Error> {
+            ) -> Result<ProbeControlCommand, eyre::Error> {
                 Ok(ProbeControlCommand {
                     timesources: [
                         (IpVersion::Ipv4, "A".to_string()),
@@ -571,7 +573,7 @@ mod tests {
         impl ManagementRequestor for SequencedCommandRequestor {
             async fn get_command(
                 _config: &ProbeControlConfig,
-            ) -> Result<ProbeControlCommand, std::io::Error> {
+            ) -> Result<ProbeControlCommand, eyre::Error> {
                 static INDEX: AtomicUsize = AtomicUsize::new(0);
                 Ok(match INDEX.load(std::sync::atomic::Ordering::SeqCst) {
                     0 => {

nts-pool-monitor/src/control.rs

@@ -60,7 +60,7 @@ impl Probe {
         &self,
         uuid: impl AsRef<str>,
         ipprot: IpVersion,
-    ) -> Result<ProbeResult, std::io::Error> {
+    ) -> Result<ProbeResult, eyre::Error> {
         let (keyexchange, next) = self.probe_keyexchange(uuid, ipprot).await?;
 
         let (ntp_with_ke_cookie, next) = match next {
@@ -84,7 +84,7 @@ impl Probe {
         &self,
         uuid: impl AsRef<str>,
         ipprot: IpVersion,
-    ) -> Result<(KeyExchangeProbeResult, Option<NtpInputs>), std::io::Error> {
+    ) -> Result<(KeyExchangeProbeResult, Option<NtpInputs>), eyre::Error> {
         let addr = resolve_as_version((self.poolke.as_str(), 4460), ipprot).await?;
         let io = TcpStream::connect(addr).await?;
 
@@ -100,14 +100,7 @@ impl Probe {
         .await
         {
             Ok(Ok(result)) => result,
-            Ok(Err(NtsError::IO(e))) => return Err(e),
-            Ok(Err(NtsError::Tls(e))) => return Err(std::io::Error::other(e)),
-            Ok(Err(NtsError::Dns(e))) => return Err(std::io::Error::other(e)),
-            Ok(Err(NtsError::UnrecognizedCriticalRecord))
-            | Ok(Err(NtsError::UnknownWarning(_))) => {
-                return Err(std::io::ErrorKind::InvalidData.into());
-            }
-            Ok(Err(_)) => {
+            Ok(Err(NtsError::Invalid | NtsError::Error(_))) => {
                 let end_time = Instant::now();
                 return Ok((
                     KeyExchangeProbeResult {
@@ -119,6 +112,7 @@ impl Probe {
                     None,
                 ));
             }
+            Ok(Err(e)) => return Err(e.into()),
             Err(_) => {
                 let end_time = Instant::now();
                 return Ok((