add open_message entity and main provider

Author: ghubertpalo

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

@@ -1,6 +1,7 @@
 //! Aggregator related database providers
 mod certificate;
 mod epoch_setting;
+mod open_message;
 mod stake_pool;
 
 pub use certificate::*;

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

@@ -0,0 +1,201 @@
+use chrono::NaiveDateTime;
+use mithril_common::entities::Beacon;
+use mithril_common::entities::Epoch;
+
+use mithril_common::sqlite::Provider;
+use mithril_common::sqlite::SourceAlias;
+use mithril_common::{
+    entities::SignedEntityType,
+    sqlite::{HydrationError, Projection, SqLiteEntity, WhereCondition},
+};
+use sqlite::Row;
+use sqlite::{Connection, Value};
+
+/// ## 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.
+struct OpenMessage {
+    open_message_id: String,
+    epoch: Epoch,
+    beacon: Beacon,
+    signed_entity_type: SignedEntityType,
+    message: String,
+    created_at: NaiveDateTime,
+}
+
+impl SqLiteEntity for OpenMessage {
+    fn hydrate(row: Row) -> Result<Self, HydrationError>
+    where
+        Self: Sized,
+    {
+        let open_message_id = row.get::<String, _>(0);
+        let message = row.get::<String, _>(4);
+        let epoch_settings_id = row.get::<i64, _>(1);
+        let epoch_val = u64::try_from(epoch_settings_id)
+            .map_err(|e| panic!("Integer field open_message.epoch_settings_id (value={epoch_settings_id}) is incompatible with u64 Epoch representation. Error = {e}"))?;
+
+        let signed_entity_type_id = usize::try_from(row.get::<i64, _>(3)).map_err(|e| {
+            panic!(
+                "Integer field open_message.signed_entity_type_id cannot be turned into usize: {e}"
+            )
+        })?;
+        let signed_entity_type = SignedEntityType::from_repr(signed_entity_type_id)
+            .ok_or_else(|| HydrationError::InvalidData(format!(
+                "Field open_message.signed_type_id can be either 0, 1 or 2, ({signed_entity_type_id} given)."
+            )))?;
+        let beacon_str = row.get::<String, _>(2);
+        let beacon: Beacon = serde_json::from_str(&beacon_str).map_err(|e| {
+            HydrationError::InvalidData(format!(
+                "Invalid Beacon JSON in open_message.beacon: '{beacon_str}'. Error: {e}"
+            ))
+        })?;
+        let datetime = &row.get::<String, _>(5);
+        let created_at =
+            NaiveDateTime::parse_from_str(datetime, "%Y-%m-%d %H:%M:%S").map_err(|e| {
+                HydrationError::InvalidData(format!(
+                    "Could not turn open_message.created_at field value '{datetime}' to NaiveDateTime. Error: {e}"
+                ))
+            })?;
+
+        let open_message = Self {
+            open_message_id,
+            epoch: Epoch(epoch_val),
+            beacon,
+            signed_entity_type,
+            message,
+            created_at,
+        };
+
+        Ok(open_message)
+    }
+
+    fn get_projection() -> Projection {
+        Projection::from(&[
+            ("open_message_id", "{:open_message:}.open_message_id", "int"),
+            (
+                "epoch_settings_id",
+                "{:open_message:}.epoch_settings_id",
+                "int",
+            ),
+            ("beacon", "{:open_message:}.beacon", "text"),
+            (
+                "signed_entity_type_id",
+                "{:open_message:}.signed_entity_type_id",
+                "int",
+            ),
+            ("message", "{:open_message:}.message", "text"),
+            ("created_at", "{:open_message:}.created_at", "text"),
+        ])
+    }
+}
+
+struct OpenMessageProvider<'client> {
+    connection: &'client Connection,
+}
+
+impl<'client> OpenMessageProvider<'client> {
+    fn new(connection: &'client Connection) -> Self {
+        Self { connection }
+    }
+
+    fn get_epoch_condition(&self, epoch: Epoch) -> WhereCondition {
+        WhereCondition::new(
+            "{:open_message:}.epoch_settings_id = ?*",
+            vec![Value::Integer(epoch.0 as i64)],
+        )
+    }
+
+    fn get_signed_entity_type_condition(
+        &self,
+        signed_entity_type: &SignedEntityType,
+    ) -> WhereCondition {
+        WhereCondition::new(
+            "{:open_message:}.signed_entity_type_id = ?*",
+            vec![Value::Integer(*signed_entity_type as i64)],
+        )
+    }
+
+    fn get_open_message_id_condition(&self, open_message_id: &str) -> WhereCondition {
+        WhereCondition::new(
+            "{:open_message:}.open_message_id = ?*",
+            vec![Value::String(open_message_id.to_owned())],
+        )
+    }
+}
+
+impl<'client> Provider<'client> for OpenMessageProvider<'client> {
+    type Entity = OpenMessage;
+
+    fn get_definition(&self, condition: &str) -> String {
+        let aliases = SourceAlias::new(&[("{:open_message:}", "open_message")]);
+        let projection = Self::Entity::get_projection().expand(aliases);
+
+        format!("select {projection} from open_message where {condition} order by created_at desc")
+    }
+
+    fn get_connection(&'client self) -> &'client Connection {
+        self.connection
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use mithril_common::sqlite::SourceAlias;
+
+    use super::*;
+
+    #[test]
+    fn open_message_projection() {
+        let projection = OpenMessage::get_projection();
+        let aliases = SourceAlias::new(&[("{:open_message:}", "open_message")]);
+
+        assert_eq!(
+            "open_message.open_message_id as open_message_id, open_message.epoch_settings_id as epoch_settings_id, open_message.beacon as beacon, open_message.signed_entity_type_id as signed_entity_type_id, open_message.message as message, open_message.created_at as created_at".to_string(),
+            projection.expand(aliases)
+        )
+    }
+
+    #[test]
+    fn provider_epoch_condition() {
+        let connection = Connection::open(":memory:").unwrap();
+        let provider = OpenMessageProvider::new(&connection);
+        let (expr, params) = provider.get_epoch_condition(Epoch(12)).expand();
+
+        assert_eq!("{:open_message:}.epoch_settings_id = ?1".to_string(), expr);
+        assert_eq!(vec![Value::Integer(12)], params,);
+    }
+
+    #[test]
+    fn provider_message_type_condition() {
+        let connection = Connection::open(":memory:").unwrap();
+        let provider = OpenMessageProvider::new(&connection);
+        let (expr, params) = provider
+            .get_signed_entity_type_condition(&SignedEntityType::CardanoImmutableFilesFull)
+            .expand();
+
+        assert_eq!(
+            "{:open_message:}.signed_entity_type_id = ?1".to_string(),
+            expr
+        );
+        assert_eq!(vec![Value::Integer(2)], params,);
+    }
+
+    #[test]
+    fn provider_message_id_condition() {
+        let connection = Connection::open(":memory:").unwrap();
+        let provider = OpenMessageProvider::new(&connection);
+        let (expr, params) = provider
+            .get_open_message_id_condition("cecd7983-8b3a-42b1-b778-6d75e87828ee")
+            .expand();
+
+        assert_eq!("{:open_message:}.open_message_id = ?1".to_string(), expr);
+        assert_eq!(
+            vec![Value::String(
+                "cecd7983-8b3a-42b1-b778-6d75e87828ee".to_string()
+            )],
+            params,
+        );
+    }
+}

mithril-common/src/entities/signed_entity_type.rs

@@ -1,9 +1,12 @@
 use strum::IntoEnumIterator;
 use strum_macros::{Display, EnumIter, EnumString, FromRepr};
 
-/// The signed entity type that represents a type of data signed by the Mithril protocol
-/// Note: Each variant of this enum must be associated to an entry in the `signed_entity_type` tables of the signer/aggregator nodes.
-///       The variant are identified by their discriminant (i.e. index in the enum), thus the modification of this type should only ever consist of appending new variants.
+/// The signed entity type that represents a type of data signed by the Mithril
+/// protocol Note: Each variant of this enum must be associated to an entry in
+/// the `signed_entity_type` table of the signer/aggregator nodes. The variant
+/// are identified by their discriminant (i.e. index in the enum), thus the
+/// modification of this type should only ever consist of appending new
+/// variants.
 #[derive(Display, FromRepr, EnumString, EnumIter, Debug, Clone, Copy, PartialEq, Eq)]
 #[strum(serialize_all = "PascalCase")]
 pub enum SignedEntityType {

mithril-common/src/sqlite/projection.rs

@@ -49,6 +49,16 @@ impl Projection {
         Self { fields }
     }
 
+    /// Create a Projection from a list of tuples `&[(name, definition, sql_type)]`.
+    pub fn from(fields: &[(&str, &str, &str)]) -> Self {
+        let field_defs: Vec<ProjectionField> = fields
+            .into_iter()
+            .map(|(name, definition, sql_type)| ProjectionField::new(name, definition, &sql_type))
+            .collect();
+
+        Self::new(field_defs)
+    }
+
     /// Add a new field to the definition. This is one of the projection
     /// building tool to create a projection out of an existing structure.
     /// This is a blanket implementation.
@@ -107,4 +117,20 @@ mod tests {
             projection.expand(aliases)
         )
     }
+
+    #[test]
+    fn list_constructor() {
+        let projection = Projection::from(&[
+            ("something_id", "{:test:}.something_id", "integer"),
+            ("name", "{:test:}.name", "text"),
+            ("created_at", "{:test:}.created_at", "timestamp"),
+        ]);
+
+        let aliases = SourceAlias::new(&[("{:test:}", "test")]);
+
+        assert_eq!(
+            "test.something_id as something_id, test.name as name, test.created_at as created_at",
+            projection.expand(aliases)
+        );
+    }
 }

mithril-common/src/sqlite/source_alias.rs

@@ -1,6 +1,9 @@
 use std::collections::{hash_map::Iter, HashMap};
 
-/// Handful tool to store SQL source aliases
+/// Handful tool to store SQL source aliases.
+/// ```
+/// let aliases = SourceAlias::new(&[("first", "one"), ("second", "two")]);
+/// ```
 #[derive(Debug, Default, Clone)]
 pub struct SourceAlias {
     /// Internal HashMap of source_name => source_alias