refactor(dmq): rename 'DmqPublisherPallas' to 'DmqPublisherClientPallas'

Author: jpraynaud

internal/mithril-dmq/src/lib.rs

@@ -8,7 +8,7 @@ pub mod test;
 
 pub use consumer::{DmqConsumerClient, DmqConsumerClientPallas};
 pub use message::DmqMessageBuilder;
-pub use publisher::{DmqPublisher, DmqPublisherPallas};
+pub use publisher::{DmqPublisherClient, DmqPublisherClientPallas};
 
 #[cfg(test)]
 pub(crate) mod test_tools {

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

@@ -1,9 +1,9 @@
 use mithril_common::{StdResult, crypto_helper::TryToBytes};
 
-/// Trait for publishing messages from a DMQ node.
+/// Trait for the client side of publishing messages from a DMQ node.
 #[cfg_attr(test, mockall::automock)]
 #[async_trait::async_trait]
-pub trait DmqPublisher<M: TryToBytes + Send + Sync>: Send + Sync {
+pub trait DmqPublisherClient<M: TryToBytes + Send + Sync>: Send + Sync {
     /// Publishes a message to the DMQ node.
     async fn publish_message(&self, message: M) -> StdResult<()>;
 }

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

@@ -8,21 +8,21 @@ use mithril_common::{
     CardanoNetwork, StdResult, crypto_helper::TryToBytes, logging::LoggerExtensions,
 };
 
-use crate::{DmqMessageBuilder, DmqPublisher};
+use crate::{DmqMessageBuilder, DmqPublisherClient};
 
-/// A DMQ publisher implementation.
+/// A DMQ client publisher implementation.
 ///
 /// This implementation is built upon the n2c mini-protocols DMQ implementation in Pallas.
-pub struct DmqPublisherPallas<M: TryToBytes + Debug> {
+pub struct DmqPublisherClientPallas<M: TryToBytes + Debug> {
     socket: PathBuf,
     network: CardanoNetwork,
     dmq_message_builder: DmqMessageBuilder,
     logger: Logger,
     phantom: PhantomData<M>,
 }
 
-impl<M: TryToBytes + Debug> DmqPublisherPallas<M> {
-    /// Creates a new instance of [DmqPublisherPallas].
+impl<M: TryToBytes + Debug> DmqPublisherClientPallas<M> {
+    /// Creates a new instance of [DmqPublisherClientPallas].
     pub fn new(
         socket: PathBuf,
         network: CardanoNetwork,
@@ -43,12 +43,12 @@ impl<M: TryToBytes + Debug> DmqPublisherPallas<M> {
         let magic = self.network.code();
         DmqClient::connect(&self.socket, magic)
             .await
-            .with_context(|| "DmqPublisherPallas failed to create a new client")
+            .with_context(|| "DmqPublisherClientPallas failed to create a new client")
     }
 }
 
 #[async_trait::async_trait]
-impl<M: TryToBytes + Debug + Sync + Send> DmqPublisher<M> for DmqPublisherPallas<M> {
+impl<M: TryToBytes + Debug + Sync + Send> DmqPublisherClient<M> for DmqPublisherClientPallas<M> {
     async fn publish_message(&self, message: M) -> StdResult<()> {
         debug!(
             self.logger,
@@ -144,7 +144,7 @@ mod tests {
         let reply_success = true;
         let server = setup_dmq_server(socket_path.clone(), reply_success);
         let client = tokio::spawn(async move {
-            let publisher = DmqPublisherPallas::new(
+            let publisher = DmqPublisherClientPallas::new(
                 socket_path,
                 CardanoNetwork::TestNet(0),
                 DmqMessageBuilder::new(
@@ -178,7 +178,7 @@ mod tests {
         let reply_success = false;
         let server = setup_dmq_server(socket_path.clone(), reply_success);
         let client = tokio::spawn(async move {
-            let publisher = DmqPublisherPallas::new(
+            let publisher = DmqPublisherClientPallas::new(
                 socket_path,
                 CardanoNetwork::TestNet(0),
                 DmqMessageBuilder::new(

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

@@ -4,9 +4,9 @@ use tokio::sync::Mutex;
 
 use mithril_common::{StdResult, crypto_helper::TryToBytes};
 
-use crate::DmqPublisher;
+use crate::DmqPublisherClient;
 
-/// A fake implementation of the [DmqPublisher] trait for testing purposes.
+/// A fake implementation of the [DmqPublisherClient] trait for testing purposes.
 pub struct DmqPublisherFake<M: TryToBytes + Debug + Send + Sync> {
     results: Mutex<VecDeque<StdResult<()>>>,
     phantom: PhantomData<M>,
@@ -23,7 +23,7 @@ impl<M: TryToBytes + Debug + Send + Sync> DmqPublisherFake<M> {
 }
 
 #[async_trait::async_trait]
-impl<M: TryToBytes + Debug + Send + Sync> DmqPublisher<M> for DmqPublisherFake<M> {
+impl<M: TryToBytes + Debug + Send + Sync> DmqPublisherClient<M> for DmqPublisherFake<M> {
     async fn publish_message(&self, _message: M) -> StdResult<()> {
         let mut results = self.results.lock().await;
 

mithril-signer/src/dependency_injection/builder.rs

@@ -42,7 +42,7 @@ use mithril_persistence::database::{ApplicationNodeType, SqlMigration};
 use mithril_persistence::sqlite::{ConnectionBuilder, SqliteConnection, SqliteConnectionPool};
 
 #[cfg(feature = "future_dmq")]
-use mithril_dmq::{DmqMessageBuilder, DmqPublisherPallas};
+use mithril_dmq::{DmqMessageBuilder, DmqPublisherClientPallas};
 
 use crate::dependency_injection::SignerDependencyContainer;
 #[cfg(feature = "future_dmq")]
@@ -430,14 +430,14 @@ impl<'a> DependenciesBuilder<'a> {
                                 ))?,
                                 chain_observer.clone(),
                             );
-                            Arc::new(SignaturePublisherDmq::new(Arc::new(DmqPublisherPallas::<
-                                RegisterSignatureMessageDmq,
-                            >::new(
-                                dmq_node_socket_path.to_owned(),
-                                *cardano_network,
-                                dmq_message_builder,
-                                self.root_logger(),
-                            )))) as Arc<dyn SignaturePublisher>
+                            Arc::new(SignaturePublisherDmq::new(Arc::new(
+                                DmqPublisherClientPallas::<RegisterSignatureMessageDmq>::new(
+                                    dmq_node_socket_path.to_owned(),
+                                    *cardano_network,
+                                    dmq_message_builder,
+                                    self.root_logger(),
+                                ),
+                            ))) as Arc<dyn SignaturePublisher>
                         }
                         _ => Arc::new(SignaturePublisherNoop) as Arc<dyn SignaturePublisher>,
                     };

mithril-signer/src/services/signature_publisher/dmq.rs

@@ -8,18 +8,18 @@ use mithril_common::{
     entities::{ProtocolMessage, SignedEntityType, SingleSignature},
     messages::RegisterSignatureMessageDmq,
 };
-use mithril_dmq::DmqPublisher;
+use mithril_dmq::DmqPublisherClient;
 
 use super::SignaturePublisher;
 
 /// DMQ implementation of the [SignaturePublisher] trait.
 pub struct SignaturePublisherDmq {
-    dmq_publisher: Arc<dyn DmqPublisher<RegisterSignatureMessageDmq>>,
+    dmq_publisher: Arc<dyn DmqPublisherClient<RegisterSignatureMessageDmq>>,
 }
 
 impl SignaturePublisherDmq {
     /// Creates a new instance of [SignaturePublisherDmq].
-    pub fn new(dmq_publisher: Arc<dyn DmqPublisher<RegisterSignatureMessageDmq>>) -> Self {
+    pub fn new(dmq_publisher: Arc<dyn DmqPublisherClient<RegisterSignatureMessageDmq>>) -> Self {
         Self { dmq_publisher }
     }
 }