[wip] message list

ghubertpalo · ghubertpalo · commit 3e17cbea9ce9 · 2023-11-21T14:52:49.000+01:00
diff --git a/mithril-aggregator/src/database/provider/message.rs b/mithril-aggregator/src/database/provider/message.rs
@@ -0,0 +1,94 @@
+use std::sync::Arc;
+
+use mithril_common::{
+    messages::{
+        CertificateListItemMessage, CertificateListItemMessageMetadata, CertificateMessage,
+        CertificateMetadataMessagePart,
+    },
+    StdResult,
+};
+use sqlite::ConnectionWithFullMutex;
+
+use super::{CertificateRecord, CertificateRecordProvider};
+
+pub struct CertificateMessageRepository {
+    connection: Arc<ConnectionWithFullMutex>,
+}
+
+impl CertificateMessageRepository {
+    pub fn new(connection: Arc<ConnectionWithFullMutex>) -> Self {
+        Self { connection }
+    }
+}
+
+impl From<CertificateRecord> for CertificateMessage {
+    fn from(value: CertificateRecord) -> Self {
+        let metadata = CertificateMetadataMessagePart {
+            protocol_version: value.protocol_version,
+            protocol_parameters: value.protocol_parameters,
+            initiated_at: value.initiated_at,
+            sealed_at: value.sealed_at,
+            signers: value.signers,
+        };
+        let (multi_signature, genesis_signature) = if value.parent_certificate_id.is_none() {
+            (String::new(), value.signature)
+        } else {
+            (value.signature, String::new())
+        };
+
+        CertificateMessage {
+            hash: value.certificate_id,
+            previous_hash: value.parent_certificate_id.unwrap_or_else(|| String::new()),
+            beacon: value.beacon,
+            metadata,
+            protocol_message: value.protocol_message,
+            signed_message: value.message,
+            aggregate_verification_key: value.aggregate_verification_key,
+            multi_signature,
+            genesis_signature,
+        }
+    }
+}
+
+impl From<CertificateRecord> for CertificateListItemMessage {
+    fn from(value: CertificateRecord) -> Self {
+        let metadata = CertificateListItemMessageMetadata {
+            protocol_version: value.protocol_version,
+            protocol_parameters: value.protocol_parameters,
+            initiated_at: value.initiated_at,
+            sealed_at: value.sealed_at,
+            total_signers: value.signers.len(),
+        };
+        let (multi_signature, genesis_signature) = if value.parent_certificate_id.is_none() {
+            (String::new(), value.signature)
+        } else {
+            (value.signature, String::new())
+        };
+
+        CertificateListItemMessage {
+            hash: value.certificate_id,
+            previous_hash: value.parent_certificate_id.unwrap_or_else(|| String::new()),
+            beacon: value.beacon,
+            metadata,
+            protocol_message: value.protocol_message,
+            signed_message: value.message,
+            aggregate_verification_key: value.aggregate_verification_key,
+        }
+    }
+}
+
+impl CertificateMessageRepository {
+    pub async fn get_certificate(&self, hash: &str) -> StdResult<Option<CertificateMessage>> {
+        let provider = CertificateRecordProvider::new(&self.connection);
+        let mut cursor = provider.get_by_certificate_id(hash)?;
+
+        Ok(cursor.next().map(|v| v.into()))
+    }
+
+    pub async fn get_last(&self, limit: usize) -> StdResult<Vec<CertificateListItemMessage>> {
+        let provider = CertificateRecordProvider::new(&self.connection);
+        let cursor = provider.get_all()?;
+
+        Ok(cursor.into_iter().take(limit).map(|v| v.into()).collect())
+    }
+}
diff --git a/mithril-aggregator/src/database/provider/mod.rs b/mithril-aggregator/src/database/provider/mod.rs
@@ -1,6 +1,7 @@
 //! Aggregator related database providers
 mod certificate;
 mod epoch_setting;
+mod message;
 mod open_message;
 mod signed_entity;
 mod signer;
@@ -12,6 +13,7 @@ mod test_helper;
 
 pub use certificate::*;
 pub use epoch_setting::*;
+pub use message::*;
 pub use open_message::*;
 pub use signed_entity::*;
 pub use signer::*;
diff --git a/mithril-aggregator/src/dependency_injection/builder.rs b/mithril-aggregator/src/dependency_injection/builder.rs
@@ -45,16 +45,16 @@ use crate::{
     },
     configuration::ExecutionEnvironment,
     database::provider::{
-        CertificateRepository, EpochSettingStore, OpenMessageRepository, SignedEntityStoreAdapter,
-        SignedEntityStorer, SignerRegistrationStore, SignerStore, SingleSignatureRepository,
-        StakePoolStore,
+        CertificateMessageRepository, CertificateRepository, EpochSettingStore,
+        OpenMessageRepository, SignedEntityStoreAdapter, SignedEntityStorer,
+        SignerRegistrationStore, SignerStore, SingleSignatureRepository, StakePoolStore,
     },
     event_store::{EventMessage, EventStore, TransmitterService},
     http_server::routes::router,
     services::{
-        CertifierService, MithrilCertifierService, MithrilEpochService, MithrilSignedEntityService,
-        MithrilStakeDistributionService, MithrilTickerService, SignedEntityService,
-        StakeDistributionService, TickerService,
+        CertifierService, HttpMessageService, MithrilCertifierService, MithrilEpochService,
+        MithrilHttpMessageService, MithrilSignedEntityService, MithrilStakeDistributionService,
+        MithrilTickerService, SignedEntityService, StakeDistributionService, TickerService,
     },
     tools::{CExplorerSignerRetriever, GcpFileUploader, GenesisToolsDependency, SignersImporter},
     AggregatorConfig, AggregatorRunner, AggregatorRuntime, CertificatePendingStore,
@@ -185,6 +185,9 @@ pub struct DependenciesBuilder {
 
     /// Signed Entity storer
     pub signed_entity_storer: Option<Arc<dyn SignedEntityStorer>>,
+
+    /// HTTP Message service
+    pub http_message_service: Option<Arc<dyn HttpMessageService>>,
 }
 
 impl DependenciesBuilder {
@@ -225,6 +228,7 @@ impl DependenciesBuilder {
             certifier_service: None,
             epoch_service: None,
             signed_entity_storer: None,
+            http_message_service: None,
         }
     }
 
@@ -1208,7 +1212,26 @@ impl DependenciesBuilder {
         Ok(self.certifier_service.as_ref().cloned().unwrap())
     }
 
-    /// Remove the dependencies builder from memory to release Arc.
+    /// build HTTP message service
+    pub async fn build_http_message_service(&mut self) -> Result<Arc<dyn HttpMessageService>> {
+        let certificate_message_repository = Arc::new(CertificateMessageRepository::new(
+            self.get_sqlite_connection().await?,
+        ));
+        let service = MithrilHttpMessageService::new(certificate_message_repository);
+
+        Ok(Arc::new(service))
+    }
+
+    /// [HttpMessageService] service
+    pub async fn get_http_message_service(&mut self) -> Result<Arc<dyn HttpMessageService>> {
+        if self.http_message_service.is_none() {
+            self.http_message_service = Some(self.build_http_message_service().await?);
+        }
+
+        Ok(self.http_message_service.as_ref().cloned().unwrap())
+    }
+
+    /// Remove the dependencies builder from memory to release Arc instances.
     pub async fn vanish(self) {
         self.drop_sqlite_connection().await;
     }
diff --git a/mithril-aggregator/src/services/http_message.rs b/mithril-aggregator/src/services/http_message.rs
@@ -0,0 +1,145 @@
+//! This service is responsible of provinding HTTP server with messages as fast as possible.
+
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use thiserror::Error;
+
+use mithril_common::{
+    messages::{CertificateListMessage, CertificateMessage, CertificatePendingMessage},
+    StdResult,
+};
+
+use crate::database::provider::CertificateMessageRepository;
+
+/// Error related to the [HttpMessageService]
+#[derive(Debug, Error)]
+pub enum HttpMessageServiceError {
+    /// There is no current PendingCertificate
+    #[error("There is no current pending certificate.")]
+    PendingCertificateDoesNotExist,
+}
+/// HTTP Message service trait.
+#[async_trait]
+pub trait HttpMessageService {
+    /// Return the message representation of a certificate if it exists.
+    async fn get_certificate(
+        &self,
+        certificate_hash: &str,
+    ) -> StdResult<Option<CertificateMessage>>;
+
+    /// Return the message representation of the last N certificates
+    async fn get_last_certificates(&self, limit: usize) -> StdResult<CertificateListMessage>;
+
+    /// Return the message representation of the current pending certificate
+    async fn get_pending_certificate(&self) -> StdResult<CertificatePendingMessage>;
+}
+
+pub struct MithrilHttpMessageService {
+    certificate_message_repository: Arc<CertificateMessageRepository>,
+}
+
+impl MithrilHttpMessageService {
+    pub fn new(certificate_message_repository: Arc<CertificateMessageRepository>) -> Self {
+        Self {
+            certificate_message_repository,
+        }
+    }
+}
+
+#[async_trait]
+impl HttpMessageService for MithrilHttpMessageService {
+    async fn get_certificate(
+        &self,
+        certificate_hash: &str,
+    ) -> StdResult<Option<CertificateMessage>> {
+        self.certificate_message_repository
+            .get_certificate(certificate_hash)
+            .await
+    }
+
+    async fn get_last_certificates(&self, limit: usize) -> StdResult<CertificateListMessage> {
+        self.certificate_message_repository.get_last(limit).await
+    }
+
+    async fn get_pending_certificate(&self) -> StdResult<CertificatePendingMessage> {
+        todo!()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use mithril_common::{entities::Beacon, test_utils::MithrilFixtureBuilder};
+
+    use crate::{dependency_injection::DependenciesBuilder, Configuration};
+
+    use super::*;
+
+    #[tokio::test]
+    async fn get_no_certificate() {
+        // setup
+        let configuration = Configuration::new_sample();
+        let mut dep_builder = DependenciesBuilder::new(configuration);
+        let service = dep_builder.get_http_message_service().await.unwrap();
+
+        // test
+        let certificate_hash = "whatever";
+        let certficate_message = service.get_certificate(certificate_hash).await.unwrap();
+        assert!(certficate_message.is_none());
+    }
+
+    #[tokio::test]
+    async fn get_certificate() {
+        // setup
+        let configuration = Configuration::new_sample();
+        let mut dep_builder = DependenciesBuilder::new(configuration);
+        let service = dep_builder.get_http_message_service().await.unwrap();
+        let beacon = Beacon::new("devnet".to_string(), 3, 1);
+        let fixture = MithrilFixtureBuilder::default().with_signers(3).build();
+        let genesis_beacon = Beacon {
+            epoch: beacon.epoch - 1,
+            ..beacon.clone()
+        };
+        let genesis_certificate = fixture.create_genesis_certificate(&genesis_beacon);
+        dep_builder
+            .get_certificate_repository()
+            .await
+            .unwrap()
+            .create_certificate(genesis_certificate.clone())
+            .await
+            .unwrap();
+
+        // test
+        let certficate_message = service
+            .get_certificate(&genesis_certificate.hash)
+            .await
+            .unwrap()
+            .expect("There should be a certificate.");
+        assert_eq!(genesis_certificate.hash, certficate_message.hash);
+    }
+
+    #[tokio::test]
+    async fn get_last_certificates() {
+        let configuration = Configuration::new_sample();
+        let mut dep_builder = DependenciesBuilder::new(configuration);
+        let service = dep_builder.get_http_message_service().await.unwrap();
+        let beacon = Beacon::new("devnet".to_string(), 3, 1);
+        let fixture = MithrilFixtureBuilder::default().with_signers(3).build();
+        let genesis_beacon = Beacon {
+            epoch: beacon.epoch - 1,
+            ..beacon.clone()
+        };
+        let genesis_certificate = fixture.create_genesis_certificate(&genesis_beacon);
+        dep_builder
+            .get_certificate_repository()
+            .await
+            .unwrap()
+            .create_certificate(genesis_certificate.clone())
+            .await
+            .unwrap();
+
+        // test
+        let certficate_messages = service.get_last_certificates(5).await.unwrap();
+        assert_eq!(genesis_certificate.hash, certficate_messages[0].hash);
+    }
+}
diff --git a/mithril-aggregator/src/services/mod.rs b/mithril-aggregator/src/services/mod.rs
@@ -11,12 +11,14 @@
 
 mod certifier;
 mod epoch_service;
+mod http_message;
 mod signed_entity;
 mod stake_distribution;
 mod ticker;
 
 pub use certifier::*;
 pub use epoch_service::*;
+pub use http_message::*;
 pub use signed_entity::*;
 pub use stake_distribution::*;
 pub use ticker::*;
