fix(relay): fix clippy warning

Author: jpraynaud

mithril-relay/src/commands/signer.rs

@@ -10,7 +10,7 @@ use slog::error;
 use mithril_common::CardanoNetwork;
 use mithril_common::StdResult;
 
-use crate::{SignerRelay, SignerRelayMode};
+use crate::{SignerRelay, SignerRelayConfiguration, SignerRelayMode};
 
 use super::CommandContext;
 
@@ -81,19 +81,19 @@ impl SignerCommand {
         let cardano_network =
             CardanoNetwork::from_code(self.network.to_owned(), self.network_magic)?;
 
-        let mut relay = SignerRelay::start(
-            &addr,
-            &server_port,
+        let mut relay = SignerRelay::start(SignerRelayConfiguration {
+            address: &addr,
+            server_port: &server_port,
             #[cfg(feature = "future_dmq")]
-            &self.dmq_node_socket_path,
+            dmq_node_socket_path: &self.dmq_node_socket_path,
             #[cfg(feature = "future_dmq")]
-            &cardano_network,
+            cardano_network: &cardano_network,
             signer_registration_mode,
             signature_registration_mode,
-            &aggregator_endpoint,
-            &signer_repeater_delay,
+            aggregator_endpoint: &aggregator_endpoint,
+            signer_repeater_delay: &signer_repeater_delay,
             logger,
-        )
+        })
         .await?;
         if let Some(dial_to_address) = dial_to {
             relay.dial_peer(dial_to_address.clone())?;

mithril-relay/src/lib.rs

@@ -7,12 +7,10 @@ pub mod p2p;
 mod relay;
 mod repeater;
 
-pub use commands::Args;
-pub use commands::RelayCommands;
-pub use relay::AggregatorRelay;
-pub use relay::PassiveRelay;
-pub use relay::SignerRelay;
-pub use relay::SignerRelayMode;
+pub use commands::{Args, RelayCommands};
+pub use relay::{
+    AggregatorRelay, PassiveRelay, SignerRelay, SignerRelayConfiguration, SignerRelayMode,
+};
 
 /// The P2P topic names used by Mithril
 pub mod mithril_p2p_topic {

mithril-relay/src/relay/mod.rs

@@ -4,5 +4,4 @@ mod signer;
 
 pub use aggregator::AggregatorRelay;
 pub use passive::PassiveRelay;
-pub use signer::SignerRelay;
-pub use signer::SignerRelayMode;
+pub use signer::{SignerRelay, SignerRelayConfiguration, SignerRelayMode};

mithril-relay/src/relay/signer.rs

@@ -56,6 +56,30 @@ struct HTTPServerConfiguration<'a> {
     logger: &'a Logger,
 }
 
+/// Configuration for a Mithril Signer Relay
+pub struct SignerRelayConfiguration<'a> {
+    /// Address on which the HTTP server will listen
+    pub address: &'a Multiaddr,
+    /// Port on which the HTTP server will listen
+    pub server_port: &'a u16,
+    /// Path to the DMQ node socket file
+    #[cfg(feature = "future_dmq")]
+    pub dmq_node_socket_path: &'a Path,
+    /// Cardano network
+    #[cfg(feature = "future_dmq")]
+    pub cardano_network: &'a CardanoNetwork,
+    /// Signer registration mode
+    pub signer_registration_mode: &'a SignerRelayMode,
+    /// Signature registration mode
+    pub signature_registration_mode: &'a SignerRelayMode,
+    /// Aggregator endpoint URL
+    pub aggregator_endpoint: &'a str,
+    /// Delay for repeating a signer registration message
+    pub signer_repeater_delay: &'a Duration,
+    /// Logger for the signer relay
+    pub logger: &'a Logger,
+}
+
 /// A relay for a Mithril signer
 pub struct SignerRelay {
     http_server: TestHttpServer,
@@ -73,32 +97,22 @@ pub struct SignerRelay {
 
 impl SignerRelay {
     /// Start a relay for a Mithril signer
-    pub async fn start(
-        address: &Multiaddr,
-        server_port: &u16,
-        #[cfg(feature = "future_dmq")] dmq_node_socket_path: &Path,
-        #[cfg(feature = "future_dmq")] cardano_network: &CardanoNetwork,
-        signer_registration_mode: &SignerRelayMode,
-        signature_registration_mode: &SignerRelayMode,
-        aggregator_endpoint: &str,
-        signer_repeater_delay: &Duration,
-        logger: &Logger,
-    ) -> StdResult<Self> {
-        let relay_logger = logger.new_with_component_name::<Self>();
-        debug!(relay_logger, "Starting..."; "signer_registration_mode" => ?signer_registration_mode, "signature_registration_mode" => ?signature_registration_mode);
+    pub async fn start(config: SignerRelayConfiguration<'_>) -> StdResult<Self> {
+        let relay_logger = config.logger.new_with_component_name::<Self>();
+        debug!(relay_logger, "Starting..."; "signer_registration_mode" => ?config.signer_registration_mode, "signature_registration_mode" => ?config.signature_registration_mode);
         let (signature_tx, signature_rx) = unbounded_channel::<RegisterSignatureMessageHttp>();
         let (signer_tx, signer_rx) = unbounded_channel::<RegisterSignerMessage>();
         let signer_repeater = Arc::new(MessageRepeater::new(
             signer_tx.clone(),
-            signer_repeater_delay.to_owned(),
-            logger,
+            config.signer_repeater_delay.to_owned(),
+            config.logger,
         ));
-        let peer = Peer::new(address).start().await?;
+        let peer = Peer::new(config.address).start().await?;
         let http_server = Self::start_http_server(&HTTPServerConfiguration {
-            server_port,
-            signer_registration_mode: signer_registration_mode.to_owned(),
-            signature_registration_mode: signature_registration_mode.to_owned(),
-            aggregator_endpoint,
+            server_port: config.server_port,
+            signer_registration_mode: config.signer_registration_mode.to_owned(),
+            signature_registration_mode: config.signature_registration_mode.to_owned(),
+            aggregator_endpoint: config.aggregator_endpoint,
             signer_tx: signer_tx.clone(),
             signature_tx: signature_tx.clone(),
             signer_repeater: signer_repeater.clone(),
@@ -113,8 +127,8 @@ impl SignerRelay {
             let (signature_dmq_tx, signature_dmq_rx) = unbounded_channel::<DmqMessage>();
             #[cfg(unix)]
             let _dmq_publisher_server = Self::start_dmq_publisher_server(
-                dmq_node_socket_path,
-                cardano_network,
+                config.dmq_node_socket_path,
+                config.cardano_network,
                 signature_dmq_tx,
                 stop_rx,
                 relay_logger.clone(),

mithril-relay/tests/register_signer_signature.rs

@@ -12,7 +12,7 @@ use mithril_common::CardanoNetwork;
 use mithril_common::messages::{RegisterSignatureMessageHttp, RegisterSignerMessage};
 use mithril_common::test_utils::double::Dummy;
 use mithril_relay::{
-    PassiveRelay, SignerRelay, SignerRelayMode,
+    PassiveRelay, SignerRelay, SignerRelayConfiguration, SignerRelayMode,
     p2p::{BroadcastMessage, PeerBehaviourEvent, PeerEvent},
 };
 
@@ -49,19 +49,19 @@ async fn should_receive_registrations_from_signers_when_subscribed_to_pubsub() {
     let signature_registration_mode = SignerRelayMode::P2P;
     let aggregator_endpoint = "http://0.0.0.0:1234".to_string();
     let signer_repeater_delay = Duration::from_secs(100);
-    let mut signer_relay = SignerRelay::start(
-        &addr,
-        &server_port,
+    let mut signer_relay = SignerRelay::start(SignerRelayConfiguration {
+        address: &addr,
+        server_port: &server_port,
         #[cfg(feature = "future_dmq")]
-        &dmq_node_socket_path,
+        dmq_node_socket_path: &dmq_node_socket_path,
         #[cfg(feature = "future_dmq")]
-        &cardano_network,
-        &signer_registration_mode,
-        &signature_registration_mode,
-        &aggregator_endpoint,
-        &signer_repeater_delay,
-        &logger,
-    )
+        cardano_network: &cardano_network,
+        signer_registration_mode: &signer_registration_mode,
+        signature_registration_mode: &signature_registration_mode,
+        aggregator_endpoint: &aggregator_endpoint,
+        signer_repeater_delay: &signer_repeater_delay,
+        logger: &logger,
+    })
     .await
     .expect("Relay start failed");
     let relay_address = signer_relay.address();