refactor(protocol-config): use new shared aggregator client

Author: Alenar

Cargo.lock

@@ -12,13 +12,13 @@ include = ["**/*.rs", "Cargo.toml", "README.md", ".gitignore"]
 [dependencies]
 anyhow = { workspace = true }
 async-trait = { workspace = true }
+mithril-aggregator-client = { path = "../mithril-aggregator-client" }
 mithril-common = { path = "../../mithril-common" }
 tokio = { workspace = true }
 
 [dev-dependencies]
-http = "1.3.1"
 httpmock = "0.8.1"
-mockall = { workspace = true }
+serde_json = { workspace = true }
 slog = { workspace = true }
 slog-async = { workspace = true }
 slog-term = { workspace = true }

internal/mithril-protocol-config/Cargo.toml

@@ -4,36 +4,24 @@ use anyhow::{Context, anyhow};
 use async_trait::async_trait;
 use std::sync::Arc;
 
+use mithril_aggregator_client::AggregatorHttpClient;
+use mithril_aggregator_client::query::GetProtocolConfigurationQuery;
 use mithril_common::StdResult;
 use mithril_common::entities::Epoch;
-use mithril_common::messages::ProtocolConfigurationMessage;
 
 use crate::interface::MithrilNetworkConfigurationProvider;
 use crate::model::{MithrilNetworkConfiguration, MithrilNetworkConfigurationForEpoch};
 
-/// Trait to retrieve protocol configuration
-#[cfg_attr(test, mockall::automock)]
-#[async_trait]
-pub trait ProtocolConfigurationRetrieverFromAggregator: Sync + Send {
-    /// Retrieves protocol configuration for a given epoch from the aggregator
-    async fn retrieve_protocol_configuration(
-        &self,
-        epoch: Epoch,
-    ) -> StdResult<ProtocolConfigurationMessage>;
-}
-
 /// Structure implementing MithrilNetworkConfigurationProvider using HTTP.
 pub struct HttpMithrilNetworkConfigurationProvider {
-    protocol_configuration_retriever: Arc<dyn ProtocolConfigurationRetrieverFromAggregator>,
+    aggregator_http_client: Arc<AggregatorHttpClient>,
 }
 
 impl HttpMithrilNetworkConfigurationProvider {
     /// HttpMithrilNetworkConfigurationProvider factory
-    pub fn new(
-        protocol_configuration_retriever: Arc<dyn ProtocolConfigurationRetrieverFromAggregator>,
-    ) -> Self {
+    pub fn new(aggregator_http_client: Arc<AggregatorHttpClient>) -> Self {
         Self {
-            protocol_configuration_retriever,
+            aggregator_http_client,
         }
     }
 }
@@ -52,21 +40,30 @@ impl MithrilNetworkConfigurationProvider for HttpMithrilNetworkConfigurationProv
         let registration_epoch = epoch.offset_to_next_signer_retrieval_epoch().next();
 
         let configuration_for_aggregation: MithrilNetworkConfigurationForEpoch = self
-            .protocol_configuration_retriever
-            .retrieve_protocol_configuration(aggregation_epoch)
+            .aggregator_http_client
+            .send(GetProtocolConfigurationQuery::epoch(aggregation_epoch))
             .await?
+            .ok_or(anyhow!(
+                "Missing network configuration for aggregation epoch {aggregation_epoch}"
+            ))?
             .into();
 
         let configuration_for_next_aggregation = self
-            .protocol_configuration_retriever
-            .retrieve_protocol_configuration(next_aggregation_epoch)
+            .aggregator_http_client
+            .send(GetProtocolConfigurationQuery::epoch(next_aggregation_epoch))
             .await?
+            .ok_or(anyhow!(
+                "Missing network configuration for next aggregation epoch {next_aggregation_epoch}"
+            ))?
             .into();
 
         let configuration_for_registration = self
-            .protocol_configuration_retriever
-            .retrieve_protocol_configuration(registration_epoch)
+            .aggregator_http_client
+            .send(GetProtocolConfigurationQuery::epoch(registration_epoch))
             .await?
+            .ok_or(anyhow!(
+                "Missing network configuration for registration epoch {registration_epoch}"
+            ))?
             .into();
 
         configuration_for_aggregation.signed_entity_types_config.cardano_transactions.clone()
@@ -85,65 +82,57 @@ impl MithrilNetworkConfigurationProvider for HttpMithrilNetworkConfigurationProv
 
 #[cfg(test)]
 mod tests {
-    use mockall::predicate::eq;
+    use httpmock::MockServer;
     use std::sync::Arc;
 
-    use mithril_common::{
-        entities::{Epoch, ProtocolParameters},
-        messages::ProtocolConfigurationMessage,
-        test::double::Dummy,
-    };
+    use mithril_common::entities::ProtocolParameters;
+    use mithril_common::messages::ProtocolConfigurationMessage;
+    use mithril_common::test::double::Dummy;
+
+    use crate::test::test_tools::TestLogger;
 
-    use crate::{
-        http_client::http_impl::{
-            HttpMithrilNetworkConfigurationProvider,
-            MockProtocolConfigurationRetrieverFromAggregator,
-        },
-        interface::MithrilNetworkConfigurationProvider,
-    };
+    use super::*;
 
     #[tokio::test]
     async fn test_get_network_configuration_retrieve_configurations_for_aggregation_next_aggregation_and_registration()
      {
-        let mut protocol_configuration_retriever =
-            MockProtocolConfigurationRetrieverFromAggregator::new();
-
-        protocol_configuration_retriever
-            .expect_retrieve_protocol_configuration()
-            .once()
-            .with(eq(Epoch(41)))
-            .returning(|_| {
-                Ok(ProtocolConfigurationMessage {
-                    protocol_parameters: ProtocolParameters::new(1000, 100, 0.1),
-                    ..Dummy::dummy()
-                })
-            });
-
-        protocol_configuration_retriever
-            .expect_retrieve_protocol_configuration()
-            .once()
-            .with(eq(Epoch(42)))
-            .returning(|_| {
-                Ok(ProtocolConfigurationMessage {
-                    protocol_parameters: ProtocolParameters::new(2000, 200, 0.2),
-                    ..Dummy::dummy()
-                })
-            });
-
-        protocol_configuration_retriever
-            .expect_retrieve_protocol_configuration()
-            .once()
-            .with(eq(Epoch(43)))
-            .returning(|_| {
-                Ok(ProtocolConfigurationMessage {
-                    protocol_parameters: ProtocolParameters::new(3000, 300, 0.3),
-                    ..Dummy::dummy()
-                })
-            });
-
-        let mithril_configuration_provider = HttpMithrilNetworkConfigurationProvider::new(
-            Arc::new(protocol_configuration_retriever),
-        );
+        let configuration_epoch_41 = ProtocolConfigurationMessage {
+            protocol_parameters: ProtocolParameters::new(1000, 100, 0.1),
+            ..Dummy::dummy()
+        };
+        let configuration_epoch_42 = ProtocolConfigurationMessage {
+            protocol_parameters: ProtocolParameters::new(2000, 200, 0.2),
+            ..Dummy::dummy()
+        };
+        let configuration_epoch_43 = ProtocolConfigurationMessage {
+            protocol_parameters: ProtocolParameters::new(3000, 300, 0.3),
+            ..Dummy::dummy()
+        };
+
+        let server = MockServer::start();
+        server.mock(|when, then| {
+            when.path("/protocol-configuration/41");
+            then.status(200)
+                .body(serde_json::to_string(&configuration_epoch_41).unwrap());
+        });
+        server.mock(|when, then| {
+            when.path("/protocol-configuration/42");
+            then.status(200)
+                .body(serde_json::to_string(&configuration_epoch_42).unwrap());
+        });
+        server.mock(|when, then| {
+            when.path("/protocol-configuration/43");
+            then.status(200)
+                .body(serde_json::to_string(&configuration_epoch_43).unwrap());
+        });
+
+        let mithril_configuration_provider =
+            HttpMithrilNetworkConfigurationProvider::new(Arc::new(
+                AggregatorHttpClient::builder(server.base_url())
+                    .with_logger(TestLogger::stdout())
+                    .build()
+                    .unwrap(),
+            ));
 
         let configuration = mithril_configuration_provider
             .get_network_configuration(Epoch(42))

internal/mithril-protocol-config/src/http_client/http_impl.rs renamed to internal/mithril-protocol-config/src/http.rs

@@ -1,10 +1,7 @@
 #![warn(missing_docs)]
 //! This crate provides mechanisms to read and check the configuration parameters of a Mithril network.
 
-/// HTTP client Implementation for interacting with Mithril Network.
-pub mod http_client {
-    pub mod http_impl;
-}
+pub mod http;
 pub mod interface;
 pub mod model;
 pub mod test;

internal/mithril-protocol-config/src/lib.rs

@@ -23,6 +23,7 @@ chrono = { workspace = true }
 clap = { workspace = true }
 config = { workspace = true }
 hex = { workspace = true }
+mithril-aggregator-client = { path = "../internal/mithril-aggregator-client" }
 mithril-cardano-node-chain = { path = "../internal/cardano-node/mithril-cardano-node-chain" }
 mithril-cardano-node-internal-database = { path = "../internal/cardano-node/mithril-cardano-node-internal-database" }
 mithril-cli-helper = { path = "../internal/mithril-cli-helper" }

mithril-signer/Cargo.toml

@@ -6,6 +6,7 @@ use anyhow::{Context, anyhow};
 use slog::Logger;
 use tokio::sync::{Mutex, RwLock};
 
+use mithril_aggregator_client::AggregatorHttpClient;
 use mithril_cardano_node_chain::{
     chain_observer::{CardanoCliRunner, ChainObserver, ChainObserverBuilder, ChainObserverType},
     chain_reader::PallasChainReader,
@@ -41,7 +42,7 @@ use mithril_persistence::database::repository::CardanoTransactionRepository;
 use mithril_persistence::database::{ApplicationNodeType, SqlMigration};
 use mithril_persistence::sqlite::{ConnectionBuilder, SqliteConnection, SqliteConnectionPool};
 
-use mithril_protocol_config::http_client::http_impl::HttpMithrilNetworkConfigurationProvider;
+use mithril_protocol_config::http::HttpMithrilNetworkConfigurationProvider;
 
 #[cfg(feature = "future_dmq")]
 use mithril_dmq::{DmqMessageBuilder, DmqPublisherClientPallas};
@@ -269,6 +270,14 @@ impl<'a> DependenciesBuilder<'a> {
         ));
 
         let api_version_provider = Arc::new(APIVersionProvider::new(era_checker.clone()));
+        let aggregator_client_for_network_config = Arc::new(
+            AggregatorHttpClient::builder(self.config.aggregator_endpoint.clone())
+                .with_relay_endpoint(self.config.relay_endpoint.clone())
+                .with_api_version_provider(api_version_provider.clone())
+                .with_timeout(Duration::from_millis(HTTP_REQUEST_TIMEOUT_DURATION))
+                .with_logger(self.root_logger())
+                .build()?,
+        );
         let aggregator_client = Arc::new(AggregatorHTTPClient::new(
             self.config.aggregator_endpoint.clone(),
             self.config.relay_endpoint.clone(),
@@ -376,7 +385,7 @@ impl<'a> DependenciesBuilder<'a> {
         ));
         let metrics_service = Arc::new(MetricsService::new(self.root_logger())?);
         let network_configuration_service = Arc::new(HttpMithrilNetworkConfigurationProvider::new(
-            aggregator_client.clone(),
+            aggregator_client_for_network_config,
         ));
         let preloader_activation = CardanoTransactionsPreloaderActivationSigner::new(
             network_configuration_service.clone(),

mithril-signer/src/dependency_injection/builder.rs

@@ -1,8 +1,5 @@
 use anyhow::anyhow;
 use async_trait::async_trait;
-use mithril_common::StdResult;
-use mithril_common::messages::ProtocolConfigurationMessage;
-use mithril_protocol_config::http_client::http_impl::ProtocolConfigurationRetrieverFromAggregator;
 use reqwest::header::{self, HeaderValue};
 use reqwest::{self, Client, Proxy, RequestBuilder, Response, StatusCode};
 use semver::Version;
@@ -381,40 +378,6 @@ impl AggregatorClient for AggregatorHTTPClient {
     }
 }
 
-#[async_trait]
-impl ProtocolConfigurationRetrieverFromAggregator for AggregatorHTTPClient {
-    async fn retrieve_protocol_configuration(
-        &self,
-        epoch: Epoch,
-    ) -> StdResult<ProtocolConfigurationMessage> {
-        debug!(self.logger, "Retrieve protocol configuration");
-        let url = format!(
-            "{}/protocol-configuration/{}",
-            self.aggregator_endpoint, epoch
-        );
-        let response = self
-            .prepare_request_builder(self.prepare_http_client()?.get(url.clone()))
-            .send()
-            .await;
-
-        match response {
-            Ok(response) => match response.status() {
-                StatusCode::OK => {
-                    self.warn_if_api_version_mismatch(&response);
-                    match response.json::<ProtocolConfigurationMessage>().await {
-                        Ok(message) => Ok(message),
-                        Err(err) => {
-                            Err(AggregatorClientError::JsonParseFailed(anyhow!(err)).into())
-                        }
-                    }
-                }
-                _ => Err(AggregatorClientError::from_response(response).await.into()),
-            },
-            Err(err) => Err(AggregatorClientError::RemoteServerUnreachable(anyhow!(err)).into()),
-        }
-    }
-}
-
 #[cfg(test)]
 pub(crate) mod dumb {
     use mithril_common::test::double::Dummy;
@@ -681,39 +644,6 @@ mod tests {
         );
     }
 
-    mod protocol_configuration {
-
-        use super::*;
-
-        #[tokio::test]
-        async fn test_ok_200() {
-            let (server, client) = setup_server_and_client();
-            let message_expected = ProtocolConfigurationMessage::dummy();
-            let _server_mock = server.mock(|when, then| {
-                when.path("/protocol-configuration/42");
-                then.status(200).body(json!(message_expected).to_string());
-            });
-
-            let message = client.retrieve_protocol_configuration(Epoch(42)).await.unwrap();
-
-            assert_eq!(message_expected, message);
-        }
-
-        #[tokio::test]
-        async fn test_ko_500() {
-            let (server, client) = setup_server_and_client();
-            let _server_mock = server.mock(|when, then| {
-                when.path("/protocol-configuration/42");
-                then.status(500).body("an error occurred");
-            });
-
-            client
-                .retrieve_protocol_configuration(Epoch(42))
-                .await
-                .expect_err("should throw a error");
-        }
-    }
-
     #[tokio::test]
     async fn test_register_signer_ok_201() {
         let epoch = Epoch(1);