Use open message domain type in Aggregator service & stage machine

Alenar · Alenar · commit 8127ef0346a1 · 2023-04-27T11:47:25.000+02:00
diff --git a/mithril-aggregator/src/certifier_service.rs b/mithril-aggregator/src/certifier_service.rs
@@ -23,6 +23,7 @@ use crate::database::provider::{
     CertificateRepository, OpenMessageRecord, OpenMessageRepository,
     OpenMessageWithSingleSignaturesRecord, SingleSignatureRepository,
 };
+use crate::entities::OpenMessage;
 use crate::MultiSigner;
 
 #[cfg(test)]
@@ -88,14 +89,14 @@ pub trait CertifierService: Sync + Send {
         &self,
         signed_entity_type: &SignedEntityType,
         protocol_message: &ProtocolMessage,
-    ) -> StdResult<OpenMessageRecord>;
+    ) -> StdResult<OpenMessage>;
 
     /// Return the open message at the given Beacon. If the message does not
     /// exist, None is returned.
     async fn get_open_message(
         &self,
         signed_entity_type: &SignedEntityType,
-    ) -> StdResult<Option<OpenMessageWithSingleSignaturesRecord>>;
+    ) -> StdResult<Option<OpenMessage>>;
 
     /// Create a certificate if possible. If the pointed open message does
     /// not exist or has been already certified, an error is raised. If a multi
@@ -147,6 +148,19 @@ impl MithrilCertifierService {
             _logger: logger,
         }
     }
+
+    async fn get_open_message_record(
+        &self,
+        signed_entity_type: &SignedEntityType,
+    ) -> StdResult<Option<OpenMessageWithSingleSignaturesRecord>> {
+        debug!(
+            "CertifierService::get_open_message_record(signed_entity_type: {signed_entity_type:?})"
+        );
+
+        self.open_message_repository
+            .get_open_message_with_single_signatures(signed_entity_type)
+            .await
+    }
 }
 
 #[async_trait]
@@ -177,7 +191,7 @@ impl CertifierService for MithrilCertifierService {
     ) -> StdResult<()> {
         debug!("CertifierService::register_single_signature(signed_entity_type: {signed_entity_type:?}, single_signatures: {signature:?}");
         let open_message = self
-            .get_open_message(signed_entity_type)
+            .get_open_message_record(signed_entity_type)
             .await?
             .ok_or_else(|| {
                 warn!("CertifierService::register_single_signature: OpenMessage not found for type {signed_entity_type:?}.");
@@ -209,7 +223,7 @@ impl CertifierService for MithrilCertifierService {
         &self,
         signed_entity_type: &SignedEntityType,
         protocol_message: &ProtocolMessage,
-    ) -> StdResult<OpenMessageRecord> {
+    ) -> StdResult<OpenMessage> {
         debug!("CertifierService::create_open_message(signed_entity_type: {signed_entity_type:?}, protocol_message: {protocol_message:?})");
         let current_epoch = self.current_epoch.read().await;
 
@@ -223,18 +237,22 @@ impl CertifierService for MithrilCertifierService {
             open_message.open_message_id
         );
 
-        Ok(open_message)
+        Ok(open_message.into())
     }
 
     async fn get_open_message(
         &self,
         signed_entity_type: &SignedEntityType,
-    ) -> StdResult<Option<OpenMessageWithSingleSignaturesRecord>> {
+    ) -> StdResult<Option<OpenMessage>> {
         debug!("CertifierService::get_open_message(signed_entity_type: {signed_entity_type:?})");
 
-        self.open_message_repository
+        let open_message = self
+            .open_message_repository
             .get_open_message_with_single_signatures(signed_entity_type)
-            .await
+            .await?
+            .map(|record| record.into());
+
+        Ok(open_message)
     }
 
     async fn create_certificate(
@@ -243,7 +261,7 @@ impl CertifierService for MithrilCertifierService {
     ) -> StdResult<Option<Certificate>> {
         debug!("CertifierService::create_certificate(signed_entity_type: {signed_entity_type:?})");
         let open_message = self
-            .get_open_message(signed_entity_type)
+            .get_open_message_record(signed_entity_type)
             .await?
             .ok_or_else(|| {
                 warn!("CertifierService::create_certificate: OpenMessage not found for type {signed_entity_type:?}.");
@@ -521,7 +539,8 @@ mod tests {
         let mut certifier_service = setup_certifier_service(&fixture, &epochs_with_signers).await;
         certifier_service.current_epoch = Arc::new(RwLock::new(epoch));
         let mut open_message = certifier_service
-            .create_open_message(&signed_entity_type, &protocol_message)
+            .open_message_repository
+            .create_open_message(beacon.epoch, &signed_entity_type, &protocol_message)
             .await
             .unwrap();
         open_message.is_certified = true;
diff --git a/mithril-aggregator/src/entities/mod.rs b/mithril-aggregator/src/entities/mod.rs
@@ -0,0 +1,6 @@
+//! Entities module
+//!
+//! This module provide domain entities for the services & state machine.
+mod open_message;
+
+pub use open_message::OpenMessage;
diff --git a/mithril-aggregator/src/entities/open_message.rs b/mithril-aggregator/src/entities/open_message.rs
@@ -0,0 +1,134 @@
+use mithril_common::entities::{Epoch, ProtocolMessage, SignedEntityType, SingleSignatures};
+
+use crate::database::provider::{OpenMessageRecord, OpenMessageWithSingleSignaturesRecord};
+
+/// ## OpenMessage
+///
+/// An open message is a message open for signatures. Every signer may send a
+/// single signature for this message from which a multi signature will be
+/// generated if possible.
+#[derive(Debug, Clone, PartialEq)]
+pub struct OpenMessage {
+    /// OpenMessage unique identifier
+    // pub open_message_id: Uuid, // do we need it in the entity ?
+
+    /// Epoch
+    pub epoch: Epoch,
+
+    /// Type of message
+    pub signed_entity_type: SignedEntityType,
+
+    /// Message used by the Mithril Protocol
+    pub protocol_message: ProtocolMessage,
+
+    /// Has this message been converted into a Certificate?
+    pub is_certified: bool,
+
+    /// associated single signatures
+    pub single_signatures: Vec<SingleSignatures>,
+}
+
+impl OpenMessage {
+    #[cfg(test)]
+    /// Create a dumb OpenMessage instance mainly for test purposes
+    pub fn dummy() -> Self {
+        use mithril_common::test_utils::fake_data;
+
+        let beacon = mithril_common::test_utils::fake_data::beacon();
+        let epoch = beacon.epoch;
+        let signed_entity_type = SignedEntityType::CardanoImmutableFilesFull(beacon);
+
+        Self {
+            epoch,
+            signed_entity_type,
+            protocol_message: ProtocolMessage::new(),
+            is_certified: false,
+            single_signatures: vec![
+                fake_data::single_signatures(vec![1, 4, 5]),
+                fake_data::single_signatures(vec![2, 3, 8]),
+            ],
+        }
+    }
+}
+
+impl From<OpenMessageRecord> for OpenMessage {
+    fn from(record: OpenMessageRecord) -> Self {
+        Self {
+            epoch: record.epoch,
+            signed_entity_type: record.signed_entity_type,
+            protocol_message: record.protocol_message,
+            is_certified: record.is_certified,
+            single_signatures: vec![],
+        }
+    }
+}
+
+impl From<OpenMessageWithSingleSignaturesRecord> for OpenMessage {
+    fn from(record: OpenMessageWithSingleSignaturesRecord) -> Self {
+        Self {
+            epoch: record.epoch,
+            signed_entity_type: record.signed_entity_type,
+            protocol_message: record.protocol_message,
+            is_certified: record.is_certified,
+            single_signatures: record.single_signatures,
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::database::provider::{OpenMessageRecord, OpenMessageWithSingleSignaturesRecord};
+    use mithril_common::{
+        entities::{Epoch, ProtocolMessage, SignedEntityType},
+        test_utils::fake_data,
+    };
+    use std::vec;
+    use uuid::Uuid;
+
+    use super::OpenMessage;
+
+    #[test]
+    fn test_from_record() {
+        let record = OpenMessageRecord {
+            open_message_id: Uuid::new_v4(),
+            epoch: Epoch(1),
+            signed_entity_type: SignedEntityType::dummy(),
+            protocol_message: ProtocolMessage::default(),
+            is_certified: false,
+            created_at: chrono::Local::now().naive_local(),
+        };
+        let expected = OpenMessage {
+            epoch: Epoch(1),
+            signed_entity_type: SignedEntityType::dummy(),
+            protocol_message: ProtocolMessage::default(),
+            is_certified: false,
+            single_signatures: vec![],
+        };
+        let result: OpenMessage = record.into();
+
+        assert_eq!(expected, result);
+    }
+
+    #[test]
+    fn test_from_record_with_single_signatures() {
+        let record = OpenMessageWithSingleSignaturesRecord {
+            open_message_id: Uuid::new_v4(),
+            epoch: Epoch(1),
+            signed_entity_type: SignedEntityType::dummy(),
+            protocol_message: ProtocolMessage::default(),
+            is_certified: false,
+            created_at: chrono::Local::now().naive_local(),
+            single_signatures: vec![fake_data::single_signatures(vec![1, 4, 5])],
+        };
+        let expected = OpenMessage {
+            epoch: Epoch(1),
+            signed_entity_type: SignedEntityType::dummy(),
+            protocol_message: ProtocolMessage::default(),
+            is_certified: false,
+            single_signatures: vec![fake_data::single_signatures(vec![1, 4, 5])],
+        };
+        let result: OpenMessage = record.into();
+
+        assert_eq!(expected, result);
+    }
+}
diff --git a/mithril-aggregator/src/lib.rs b/mithril-aggregator/src/lib.rs
@@ -18,6 +18,7 @@ mod configuration;
 pub mod database;
 mod dependency;
 pub mod dependency_injection;
+pub mod entities;
 pub mod event_store;
 mod http_server;
 mod message_adapters;
diff --git a/mithril-aggregator/src/runtime/runner.rs b/mithril-aggregator/src/runtime/runner.rs
@@ -16,7 +16,7 @@ use std::path::Path;
 use std::path::PathBuf;
 use std::sync::Arc;
 
-use crate::database::provider::OpenMessageRecord;
+use crate::entities::OpenMessage;
 use crate::snapshot_uploaders::SnapshotLocation;
 use crate::snapshotter::OngoingSnapshot;
 use crate::RuntimeError;
@@ -172,7 +172,7 @@ pub trait AggregatorRunnerTrait: Sync + Send {
         &self,
         signed_entity_type: &SignedEntityType,
         protocol_message: &ProtocolMessage,
-    ) -> Result<OpenMessageRecord, Box<dyn StdError + Sync + Send>>;
+    ) -> Result<OpenMessage, Box<dyn StdError + Sync + Send>>;
 }
 
 /// The runner responsibility is to expose a code API for the state machine. It
@@ -614,7 +614,7 @@ impl AggregatorRunnerTrait for AggregatorRunner {
         &self,
         signed_entity_type: &SignedEntityType,
         protocol_message: &ProtocolMessage,
-    ) -> Result<OpenMessageRecord, Box<dyn StdError + Sync + Send>> {
+    ) -> Result<OpenMessage, Box<dyn StdError + Sync + Send>> {
         self.dependencies
             .certifier_service
             .create_open_message(signed_entity_type, protocol_message)
diff --git a/mithril-aggregator/src/runtime/state_machine.rs b/mithril-aggregator/src/runtime/state_machine.rs
@@ -359,7 +359,7 @@ mod tests {
 
     use std::path::Path;
 
-    use crate::database::provider::OpenMessageRecord;
+    use crate::entities::OpenMessage;
     use crate::snapshotter::OngoingSnapshot;
 
     use super::super::runner::MockAggregatorRunner;
@@ -607,7 +607,7 @@ mod tests {
         runner
             .expect_create_open_message()
             .once()
-            .returning(|_, _| Ok(OpenMessageRecord::dummy()));
+            .returning(|_, _| Ok(OpenMessage::dummy()));
 
         let mut runtime = init_runtime(
             Some(AggregatorState::Ready(ReadyState {
diff --git a/mithril-aggregator/tests/test_extensions/open_message_observer.rs b/mithril-aggregator/tests/test_extensions/open_message_observer.rs
@@ -1,6 +1,4 @@
-use mithril_aggregator::{
-    certifier_service::CertifierService, database::provider::OpenMessageWithSingleSignaturesRecord,
-};
+use mithril_aggregator::{certifier_service::CertifierService, entities::OpenMessage};
 use mithril_common::{entities::SignedEntityType, BeaconProvider};
 use std::sync::Arc;
 
@@ -23,9 +21,7 @@ impl OpenMessageObserver {
     }
 
     // Get the current [open message][OpenMessageWithSingleSignatures] for [cardano immutables][SignedEntityType::CardanoImmutableFilesFull]
-    pub async fn get_current_immutable_message(
-        &self,
-    ) -> Result<Option<OpenMessageWithSingleSignaturesRecord>, String> {
+    pub async fn get_current_immutable_message(&self) -> Result<Option<OpenMessage>, String> {
         let immutable_signer_entity_type = SignedEntityType::CardanoImmutableFilesFull(
             self.beacon_provider
                 .get_current_beacon()
