Add /signers/tickers route to aggregator

Author: Alenar

mithril-aggregator/src/database/provider/signer.rs

@@ -13,6 +13,9 @@ use mithril_common::StdResult;
 
 use crate::signer_registerer::SignerRecorder;
 
+#[cfg(test)]
+use mockall::automock;
+
 /// Signer record is the representation of a stored signer.
 #[derive(Debug, PartialEq, Clone)]
 pub struct SignerRecord {
@@ -273,6 +276,14 @@ impl<'conn> Provider<'conn> for ImportSignerRecordProvider<'conn> {
     }
 }
 
+/// Service to get [SignerRecord].
+#[cfg_attr(test, automock)]
+#[async_trait]
+pub trait SignerGetter: Sync + Send {
+    /// Return all stored records.
+    async fn get_all(&self) -> StdResult<Vec<SignerRecord>>;
+}
+
 /// Service to deal with signer (read & write).
 pub struct SignerStore {
     connection: Arc<Mutex<Connection>>,
@@ -284,15 +295,6 @@ impl SignerStore {
         Self { connection }
     }
 
-    /// Return all stored [SignerRecord].
-    pub async fn get_all(&self) -> StdResult<Vec<SignerRecord>> {
-        let connection = &*self.connection.lock().await;
-        let provider = SignerRecordProvider::new(connection);
-        let cursor = provider.get_all()?;
-
-        Ok(cursor.collect())
-    }
-
     /// Import a signer in the database, its registered_at date will be left empty
     pub async fn import_signer(
         &self,
@@ -363,6 +365,17 @@ impl SignerRecorder for SignerStore {
     }
 }
 
+#[async_trait]
+impl SignerGetter for SignerStore {
+    async fn get_all(&self) -> StdResult<Vec<SignerRecord>> {
+        let connection = &*self.connection.lock().await;
+        let provider = SignerRecordProvider::new(connection);
+        let cursor = provider.get_all()?;
+
+        Ok(cursor.collect())
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::database::provider::apply_all_migrations_to_db;

mithril-aggregator/src/dependency_injection/builder.rs

@@ -39,7 +39,6 @@ use tokio::{
 };
 use warp::Filter;
 
-use crate::tools::{CExplorerSignerTickerRetriever, SignerTickersImporter, SignerTickersPersister};
 use crate::{
     artifact_builder::{
         CardanoImmutableFilesFullArtifactBuilder, MithrilStakeDistributionArtifactBuilder,
@@ -57,8 +56,10 @@ use crate::{
         MithrilStakeDistributionService, MithrilTickerService, SignedEntityService,
         StakeDistributionService, TickerService,
     },
-    signer_registerer::SignerRecorder,
-    tools::{GcpFileUploader, GenesisToolsDependency},
+    tools::{
+        CExplorerSignerTickerRetriever, GcpFileUploader, GenesisToolsDependency,
+        SignerTickersImporter,
+    },
     AggregatorConfig, AggregatorRunner, AggregatorRuntime, CertificatePendingStore,
     CompressedArchiveSnapshotter, Configuration, DependencyContainer, DumbSnapshotUploader,
     DumbSnapshotter, LocalSnapshotUploader, MithrilSignerRegisterer, MultiSigner, MultiSignerImpl,
@@ -671,7 +672,7 @@ impl DependenciesBuilder {
         let registerer = MithrilSignerRegisterer::new(
             self.get_chain_observer().await?,
             self.get_verification_key_store().await?,
-            self.get_signer_recorder().await?,
+            self.get_signer_store().await?,
             self.configuration.safe_epoch_retention_limit(),
         );
 
@@ -862,22 +863,16 @@ impl DependenciesBuilder {
         Ok(signer_store)
     }
 
-    /// [SignerRecorder] service
-    pub async fn get_signer_recorder(&mut self) -> Result<Arc<dyn SignerRecorder>> {
-        if self.signer_store.is_none() {
-            self.signer_store = Some(self.build_signer_store().await?);
-        }
-
-        Ok(self.signer_store.as_ref().cloned().unwrap())
-    }
-
-    /// [SignerTickersPersister] service
-    pub async fn get_signer_ticker_persister(&mut self) -> Result<Arc<dyn SignerTickersPersister>> {
-        if self.signer_store.is_none() {
-            self.signer_store = Some(self.build_signer_store().await?);
+    /// [SignerStore] service
+    pub async fn get_signer_store(&mut self) -> Result<Arc<SignerStore>> {
+        match self.signer_store.as_ref().cloned() {
+            None => {
+                let store = self.build_signer_store().await?;
+                self.signer_store = Some(store.clone());
+                Ok(store)
+            }
+            Some(store) => Ok(store),
         }
-
-        Ok(self.signer_store.as_ref().cloned().unwrap())
     }
 
     async fn build_signable_builder_service(&mut self) -> Result<Arc<dyn SignableBuilderService>> {
@@ -984,12 +979,13 @@ impl DependenciesBuilder {
             event_transmitter: self.get_event_transmitter().await?,
             api_version_provider: self.get_api_version_provider().await?,
             stake_distribution_service: self.get_stake_distribution_service().await?,
-            signer_recorder: self.get_signer_recorder().await?,
+            signer_recorder: self.get_signer_store().await?,
             signable_builder_service: self.get_signable_builder_service().await?,
             signed_entity_service: self.get_signed_entity_service().await?,
             certifier_service: self.get_certifier_service().await?,
             ticker_service: self.get_ticker_service().await?,
             signed_entity_storer: self.get_signed_entity_storer().await?,
+            signer_getter: self.get_signer_store().await?,
         };
 
         Ok(dependency_manager)
@@ -1110,7 +1106,7 @@ impl DependenciesBuilder {
             cexplorer_pools_url,
             Some(Duration::from_secs(30)),
         )?;
-        let persister = self.get_signer_ticker_persister().await?;
+        let persister = self.get_signer_store().await?;
 
         Ok(SignerTickersImporter::new(Arc::new(retriever), persister))
     }

mithril-aggregator/src/dependency_injection/containers.rs

@@ -16,10 +16,9 @@ use mithril_common::{
     BeaconProvider,
 };
 
-use crate::database::provider::CertificateRepository;
 use crate::{
     configuration::*,
-    database::provider::{SignedEntityStorer, StakePoolStore},
+    database::provider::{CertificateRepository, SignedEntityStorer, SignerGetter, StakePoolStore},
     event_store::{EventMessage, TransmitterService},
     multi_signer::MultiSigner,
     services::{CertifierService, SignedEntityService, StakeDistributionService, TickerService},
@@ -123,6 +122,9 @@ pub struct DependencyContainer {
 
     /// Signed Entity storer
     pub signed_entity_storer: Arc<dyn SignedEntityStorer>,
+
+    /// Signer getter service
+    pub signer_getter: Arc<dyn SignerGetter>,
 }
 
 #[doc(hidden)]

mithril-aggregator/src/entities/mod.rs

@@ -3,8 +3,10 @@
 //! This module provide domain entities for the services & state machine.
 mod open_message;
 mod signer_registration_message;
+mod signer_ticker_message;
 
 pub use open_message::OpenMessage;
 pub use signer_registration_message::{
     SignerRegistrationsListItemMessage, SignerRegistrationsMessage,
 };
+pub use signer_ticker_message::SignerTickerMessage;

mithril-aggregator/src/entities/signer_ticker_message.rs

@@ -0,0 +1,16 @@
+use mithril_common::entities::PartyId;
+use serde::{Deserialize, Serialize};
+
+/// Message structure of a known signer
+#[derive(Clone, Debug, PartialEq, Eq, Default, Serialize, Deserialize)]
+pub struct SignerTickerMessage {
+    /// The signer party id
+    pub party_id: PartyId,
+
+    /// The signer pool ticker
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub pool_ticker: Option<String>,
+
+    /// True if the signer have registered at least once
+    pub has_registered: bool,
+}

mithril-aggregator/src/http_server/routes/middlewares.rs

@@ -7,6 +7,7 @@ use crate::{
     SignerRegisterer, VerificationKeyStorer,
 };
 
+use crate::database::provider::SignerGetter;
 use mithril_common::{api_version::APIVersionProvider, BeaconProvider};
 use std::convert::Infallible;
 use std::sync::Arc;
@@ -40,6 +41,13 @@ pub fn with_signer_registerer(
     warp::any().map(move || dependency_manager.signer_registerer.clone())
 }
 
+/// With signer getter middleware
+pub fn with_signer_getter(
+    dependency_manager: Arc<DependencyContainer>,
+) -> impl Filter<Extract = (Arc<dyn SignerGetter>,), Error = Infallible> + Clone {
+    warp::any().map(move || dependency_manager.signer_getter.clone())
+}
+
 /// With config middleware
 pub fn with_config(
     dependency_manager: Arc<DependencyContainer>,

mithril-aggregator/src/http_server/routes/signer_routes.rs

@@ -8,7 +8,9 @@ const MITHRIL_SIGNER_VERSION_HEADER: &str = "signer-node-version";
 pub fn routes(
     dependency_manager: Arc<DependencyContainer>,
 ) -> impl Filter<Extract = (impl warp::Reply,), Error = warp::Rejection> + Clone {
-    register_signer(dependency_manager.clone()).or(registered_signers(dependency_manager))
+    register_signer(dependency_manager.clone())
+        .or(registered_signers(dependency_manager.clone()))
+        .or(signers_tickers(dependency_manager))
 }
 
 /// POST /register-signer
@@ -31,6 +33,16 @@ fn register_signer(
         .and_then(handlers::register_signer)
 }
 
+/// Get /signers/tickers
+fn signers_tickers(
+    dependency_manager: Arc<DependencyContainer>,
+) -> impl Filter<Extract = (impl warp::Reply,), Error = warp::Rejection> + Clone {
+    warp::path!("signers" / "tickers")
+        .and(warp::get())
+        .and(middlewares::with_signer_getter(dependency_manager))
+        .and_then(handlers::signers_tickers)
+}
+
 /// Get /signers/registered/:epoch
 fn registered_signers(
     dependency_manager: Arc<DependencyContainer>,
@@ -42,7 +54,8 @@ fn registered_signers(
 }
 
 mod handlers {
-    use crate::entities::SignerRegistrationsMessage;
+    use crate::database::provider::SignerGetter;
+    use crate::entities::{SignerRegistrationsMessage, SignerTickerMessage};
     use crate::event_store::{EventMessage, TransmitterService};
     use crate::{http_server::routes::reply, SignerRegisterer, SignerRegistrationError};
     use crate::{FromRegisterSignerAdapter, VerificationKeyStorer};
@@ -187,6 +200,30 @@ mod handlers {
             }
         }
     }
+
+    pub async fn signers_tickers(
+        signer_getter: Arc<dyn SignerGetter>,
+    ) -> Result<impl warp::Reply, Infallible> {
+        debug!("⇄ HTTP SERVER: signers/tickers");
+
+        match signer_getter.get_all().await {
+            Ok(signers) => {
+                let message: Vec<_> = signers
+                    .into_iter()
+                    .map(|s| SignerTickerMessage {
+                        party_id: s.signer_id,
+                        pool_ticker: s.pool_ticker,
+                        has_registered: s.registered_at.is_some(),
+                    })
+                    .collect();
+                Ok(reply::json(&message, StatusCode::OK))
+            }
+            Err(err) => {
+                warn!("registered_signers::error"; "error" => ?err);
+                Ok(reply::internal_server_error(err.to_string()))
+            }
+        }
+    }
 }
 
 #[cfg(test)]
@@ -204,6 +241,7 @@ mod tests {
     use serde_json::Value::Null;
     use warp::{http::Method, test::request};
 
+    use crate::database::provider::{MockSignerGetter, SignerRecord};
     use crate::{
         http_server::SERVER_BASE_PATH, initialize_dependencies,
         signer_registerer::MockSignerRegisterer, store::MockVerificationKeyStorer,
@@ -497,4 +535,79 @@ mod tests {
             &response,
         );
     }
+
+    #[tokio::test]
+    async fn test_signers_tickers_get_ok() {
+        let mut mock_signer_getter = MockSignerGetter::new();
+        mock_signer_getter
+            .expect_get_all()
+            .return_once(|| {
+                Ok(vec![
+                    SignerRecord {
+                        signer_id: "pool_without_ticker".to_string(),
+                        pool_ticker: None,
+                        created_at: Default::default(),
+                        updated_at: Default::default(),
+                        registered_at: None,
+                    },
+                    SignerRecord {
+                        signer_id: "pool_with_ticker".to_string(),
+                        pool_ticker: Some("pool_ticker".to_string()),
+                        created_at: Default::default(),
+                        updated_at: Default::default(),
+                        registered_at: None,
+                    },
+                ])
+            })
+            .once();
+        let mut dependency_manager = initialize_dependencies().await;
+        dependency_manager.signer_getter = Arc::new(mock_signer_getter);
+
+        let method = Method::GET.as_str();
+        let path = "/signers/tickers";
+
+        let response = request()
+            .method(method)
+            .path(&format!("/{SERVER_BASE_PATH}{path}"))
+            .reply(&setup_router(Arc::new(dependency_manager)))
+            .await;
+
+        APISpec::verify_conformity(
+            APISpec::get_all_spec_files(),
+            method,
+            path,
+            "application/json",
+            &Null,
+            &response,
+        );
+    }
+
+    #[tokio::test]
+    async fn test_signers_tickers_get_ko() {
+        let mut mock_signer_getter = MockSignerGetter::new();
+        mock_signer_getter
+            .expect_get_all()
+            .return_once(|| Err(anyhow!("an error")))
+            .once();
+        let mut dependency_manager = initialize_dependencies().await;
+        dependency_manager.signer_getter = Arc::new(mock_signer_getter);
+
+        let method = Method::GET.as_str();
+        let path = "/signers/tickers";
+
+        let response = request()
+            .method(method)
+            .path(&format!("/{SERVER_BASE_PATH}{path}"))
+            .reply(&setup_router(Arc::new(dependency_manager)))
+            .await;
+
+        APISpec::verify_conformity(
+            APISpec::get_all_spec_files(),
+            method,
+            path,
+            "application/json",
+            &Null,
+            &response,
+        );
+    }
 }

mithril-aggregator/src/tools/signer_tickers_importer.rs

@@ -188,7 +188,7 @@ mod tests {
     use warp::Filter;
 
     use crate::database::provider::{
-        apply_all_migrations_to_db, disable_foreign_key_support, SignerStore,
+        apply_all_migrations_to_db, disable_foreign_key_support, SignerGetter, SignerStore,
     };
     use crate::http_server::routes::reply;