refactor(dmq): better anyhow usage

Co-authored-by: DJO <[email protected]>

Author: jpraynaud

internal/mithril-dmq-node/src/consumer/pallas.rs

@@ -47,7 +47,6 @@ impl<M: TryFromBytes + Debug> DmqConsumerPallas<M> {
         );
         DmqClient::connect(&self.socket, self.network.code())
             .await
-            .map_err(|err| anyhow!(err))
             .with_context(|| "DmqConsumerPallas failed to create a new client")
     }
 
@@ -101,13 +100,13 @@ impl<M: TryFromBytes + Debug> DmqConsumerPallas<M> {
             .msg_notification()
             .send_request_messages_blocking()
             .await
-            .map_err(|err| anyhow!("Failed to request notifications from DMQ server: {}", err))?;
+            .with_context(|| "Failed to request notifications from DMQ server: {}")?;
 
         let reply = client
             .msg_notification()
             .recv_next_reply()
             .await
-            .map_err(|err| anyhow!("Failed to receive notifications from DMQ server: {}", err))?;
+            .with_context(|| "Failed to receive notifications from DMQ server")?;
         debug!(self.logger, "Received single signatures from DMQ"; "messages" => ?reply);
         if let Err(e) = client.msg_notification().send_done().await {
             error!(self.logger, "Failed to send Done"; "error" => ?e);
@@ -118,10 +117,10 @@ impl<M: TryFromBytes + Debug> DmqConsumerPallas<M> {
             .into_iter()
             .map(|dmq_message| {
                 let opcert = OpCert::try_from_bytes(&dmq_message.operational_certificate)
-                    .map_err(|e| anyhow!("Failed to parse operational certificate: {}", e))?;
+                    .with_context(|| "Failed to parse operational certificate")?;
                 let party_id = opcert.compute_protocol_party_id()?;
                 let payload = M::try_from_bytes(&dmq_message.msg_body)
-                    .map_err(|e| anyhow!("Failed to parse DMQ message body: {}", e))?;
+                    .with_context(|| "Failed to parse DMQ message body")?;
 
                 Ok((payload, party_id))
             })

internal/mithril-dmq-node/src/message.rs

@@ -70,7 +70,7 @@ impl DmqMessageBuilder {
             .block_number;
         let block_number = (*block_number)
             .try_into()
-            .map_err(|_| anyhow!("Failed to convert block number to u32"))?;
+            .with_context(|| "Failed to convert block number to u32")?;
         let (kes_signature, operational_certificate) = self
             .kes_signer
             .sign(message_bytes, block_number)

internal/mithril-dmq-node/src/publisher/pallas.rs

@@ -1,6 +1,6 @@
 use std::{fmt::Debug, marker::PhantomData, path::PathBuf};
 
-use anyhow::{anyhow, Context};
+use anyhow::Context;
 use pallas_network::{facades::DmqClient, miniprotocols::localtxsubmission::Response};
 use slog::{debug, error, Logger};
 
@@ -43,7 +43,6 @@ impl<M: TryToBytes + Debug> DmqPublisherPallas<M> {
         let magic = self.network.code();
         DmqClient::connect(&self.socket, magic)
             .await
-            .map_err(|err| anyhow!(err))
             .with_context(|| "DmqPublisherPallas failed to create a new client")
     }
 }
@@ -67,14 +66,14 @@ impl<M: TryToBytes + Debug + Sync + Send> DmqPublisher<M> for DmqPublisherPallas
             .msg_submission()
             .send_submit_tx(dmq_message)
             .await
-            .map_err(|err| anyhow!("Failed to submit DMQ message: {}", err))?;
+            .with_context(|| "Failed to submit DMQ message")?;
         let response = client.msg_submission().recv_submit_tx_response().await?;
         if let Err(e) = client.msg_submission().terminate_gracefully().await {
             error!(self.logger, "Failed to send Done"; "error" => ?e);
         }
 
         if response != Response::Accepted {
-            return Err(anyhow!("Failed to publish DMQ message: {:?}", response));
+            anyhow::bail!("Failed to publish DMQ message: {:?}", response);
         }
 
         Ok(())