refactor(dmq): rename 'DmqConsumerPallas' to 'DmqConsumerClientPallas'

Author: jpraynaud

internal/mithril-dmq/src/consumer/client/interface.rs

@@ -2,10 +2,10 @@ use std::fmt::Debug;
 
 use mithril_common::{StdResult, crypto_helper::TryFromBytes, entities::PartyId};
 
-/// Trait for consuming messages from a DMQ node.
+/// Trait for the client side of consuming messages from a DMQ node.
 #[cfg_attr(test, mockall::automock)]
 #[async_trait::async_trait]
-pub trait DmqConsumer<M: TryFromBytes + Debug + Send + Sync>: Send + Sync {
+pub trait DmqConsumerClient<M: TryFromBytes + Debug + Send + Sync>: Send + Sync {
     /// Consume messages from the DMQ node.
     async fn consume_messages(&self) -> StdResult<Vec<(M, PartyId)>>;
 }

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

@@ -12,21 +12,21 @@ use mithril_common::{
     logging::LoggerExtensions,
 };
 
-use crate::DmqConsumer;
+use crate::DmqConsumerClient;
 
-/// A DMQ consumer implementation.
+/// A DMQ client consumer implementation.
 ///
 /// This implementation is built upon the n2c mini-protocols DMQ implementation in Pallas.
-pub struct DmqConsumerPallas<M: TryFromBytes + Debug> {
+pub struct DmqConsumerClientPallas<M: TryFromBytes + Debug> {
     socket: PathBuf,
     network: CardanoNetwork,
     client: Mutex<Option<DmqClient>>,
     logger: Logger,
     phantom: PhantomData<M>,
 }
 
-impl<M: TryFromBytes + Debug> DmqConsumerPallas<M> {
-    /// Creates a new `DmqConsumerPallas` instance.
+impl<M: TryFromBytes + Debug> DmqConsumerClientPallas<M> {
+    /// Creates a new `DmqConsumerClientPallas` instance.
     pub fn new(socket: PathBuf, network: CardanoNetwork, logger: Logger) -> Self {
         Self {
             socket,
@@ -47,7 +47,7 @@ impl<M: TryFromBytes + Debug> DmqConsumerPallas<M> {
         );
         DmqClient::connect(&self.socket, self.network.code())
             .await
-            .with_context(|| "DmqConsumerPallas failed to create a new client")
+            .with_context(|| "DmqConsumerClientPallas failed to create a new client")
     }
 
     /// Gets the cached `DmqClient`, creating a new one if it does not exist.
@@ -128,7 +128,7 @@ impl<M: TryFromBytes + Debug> DmqConsumerPallas<M> {
 }
 
 #[async_trait::async_trait]
-impl<M: TryFromBytes + Debug + Sync + Send> DmqConsumer<M> for DmqConsumerPallas<M> {
+impl<M: TryFromBytes + Debug + Sync + Send> DmqConsumerClient<M> for DmqConsumerClientPallas<M> {
     async fn consume_messages(&self) -> StdResult<Vec<(M, PartyId)>> {
         let messages = self.consume_messages_internal().await;
         if messages.is_err() {
@@ -247,7 +247,7 @@ mod tests {
         let reply_messages = fake_msgs();
         let server = setup_dmq_server(socket_path.clone(), reply_messages);
         let client = tokio::spawn(async move {
-            let consumer = DmqConsumerPallas::new(
+            let consumer = DmqConsumerClientPallas::new(
                 socket_path,
                 CardanoNetwork::TestNet(0),
                 TestLogger::stdout(),
@@ -280,7 +280,7 @@ mod tests {
         let reply_messages = vec![];
         let server = setup_dmq_server(socket_path.clone(), reply_messages);
         let client = tokio::spawn(async move {
-            let consumer = DmqConsumerPallas::<DmqMessageTestPayload>::new(
+            let consumer = DmqConsumerClientPallas::<DmqMessageTestPayload>::new(
                 socket_path,
                 CardanoNetwork::TestNet(0),
                 TestLogger::stdout(),
@@ -304,7 +304,7 @@ mod tests {
         let reply_messages = fake_msgs();
         let server = setup_dmq_server(socket_path.clone(), reply_messages);
         let client = tokio::spawn(async move {
-            let consumer = DmqConsumerPallas::<DmqMessageTestPayload>::new(
+            let consumer = DmqConsumerClientPallas::<DmqMessageTestPayload>::new(
                 socket_path,
                 CardanoNetwork::TestNet(0),
                 TestLogger::stdout(),

internal/mithril-dmq/src/lib.rs

@@ -6,7 +6,7 @@ mod message;
 mod publisher;
 pub mod test;
 
-pub use consumer::{DmqConsumer, DmqConsumerPallas};
+pub use consumer::{DmqConsumerClient, DmqConsumerClientPallas};
 pub use message::DmqMessageBuilder;
 pub use publisher::{DmqPublisher, DmqPublisherPallas};
 

internal/mithril-dmq/src/test/double/consumer.rs

@@ -4,11 +4,11 @@ use tokio::sync::Mutex;
 
 use mithril_common::{StdResult, crypto_helper::TryFromBytes, entities::PartyId};
 
-use crate::DmqConsumer;
+use crate::DmqConsumerClient;
 
 type ConsumerReturn<M> = StdResult<Vec<(M, PartyId)>>;
 
-/// A fake implementation of the [DmqConsumer] trait for testing purposes.
+/// A fake implementation of the [DmqConsumerClient] trait for testing purposes.
 pub struct DmqConsumerFake<M: TryFromBytes + Debug + Send + Sync> {
     results: Mutex<VecDeque<ConsumerReturn<M>>>,
 }
@@ -23,7 +23,7 @@ impl<M: TryFromBytes + Debug + Send + Sync> DmqConsumerFake<M> {
 }
 
 #[async_trait::async_trait]
-impl<M: TryFromBytes + Debug + Send + Sync> DmqConsumer<M> for DmqConsumerFake<M> {
+impl<M: TryFromBytes + Debug + Send + Sync> DmqConsumerClient<M> for DmqConsumerFake<M> {
     async fn consume_messages(&self) -> ConsumerReturn<M> {
         let mut results = self.results.lock().await;
 

mithril-aggregator/src/dependency_injection/builder/enablers/misc.rs

@@ -12,7 +12,7 @@ use std::time::Duration;
 #[cfg(feature = "future_dmq")]
 use mithril_common::messages::RegisterSignatureMessageDmq;
 #[cfg(feature = "future_dmq")]
-use mithril_dmq::DmqConsumerPallas;
+use mithril_dmq::DmqConsumerClientPallas;
 use mithril_signed_entity_lock::SignedEntityTypeLock;
 
 use crate::database::repository::CertificateRepository;
@@ -89,11 +89,12 @@ impl DependenciesBuilder {
         #[cfg(feature = "future_dmq")]
         let signature_consumer = match self.configuration.dmq_node_socket_path() {
             Some(dmq_node_socket_path) => {
-                let dmq_consumer = Arc::new(DmqConsumerPallas::<RegisterSignatureMessageDmq>::new(
-                    dmq_node_socket_path,
-                    self.configuration.get_network()?,
-                    self.root_logger(),
-                ));
+                let dmq_consumer =
+                    Arc::new(DmqConsumerClientPallas::<RegisterSignatureMessageDmq>::new(
+                        dmq_node_socket_path,
+                        self.configuration.get_network()?,
+                        self.root_logger(),
+                    ));
                 Arc::new(SignatureConsumerDmq::new(dmq_consumer)) as Arc<dyn SignatureConsumer>
             }
             _ => Arc::new(SignatureConsumerNoop) as Arc<dyn SignatureConsumer>,

mithril-aggregator/src/services/signature_consumer/dmq.rs

@@ -9,18 +9,18 @@ use mithril_common::{
     messages::RegisterSignatureMessageDmq,
 };
 
-use mithril_dmq::DmqConsumer;
+use mithril_dmq::DmqConsumerClient;
 
 use super::SignatureConsumer;
 
 /// DMQ implementation of the [SignatureConsumer] trait.
 pub struct SignatureConsumerDmq {
-    dmq_consumer: Arc<dyn DmqConsumer<RegisterSignatureMessageDmq>>,
+    dmq_consumer: Arc<dyn DmqConsumerClient<RegisterSignatureMessageDmq>>,
 }
 
 impl SignatureConsumerDmq {
     /// Creates a new instance of [SignatureConsumerDmq].
-    pub fn new(dmq_consumer: Arc<dyn DmqConsumer<RegisterSignatureMessageDmq>>) -> Self {
+    pub fn new(dmq_consumer: Arc<dyn DmqConsumerClient<RegisterSignatureMessageDmq>>) -> Self {
         Self { dmq_consumer }
     }
 }