Remove SignerRegistrationStoreAdapter

It was superseed by the `SignerRegistrationStore`.

Author: Alenar

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

@@ -1,29 +1,25 @@
 use async_trait::async_trait;
 use chrono::{DateTime, Utc};
 use sqlite::{Connection, Value};
-use std::{
-    collections::{BTreeMap, HashMap},
-    sync::Arc,
-};
+use std::{collections::HashMap, sync::Arc};
 use tokio::sync::Mutex;
 
-use crate::VerificationKeyStorer;
-use mithril_common::entities::Signer;
-use mithril_common::store::StoreError;
 use mithril_common::{
     crypto_helper::KESPeriod,
     entities::{
         Epoch, HexEncodedOpCert, HexEncodedVerificationKey, HexEncodedVerificationKeySignature,
-        PartyId, SignerWithStake, Stake,
+        PartyId, Signer, SignerWithStake, Stake,
     },
     sqlite::{
         EntityCursor, HydrationError, Projection, Provider, SourceAlias, SqLiteEntity,
         WhereCondition,
     },
-    store::adapter::{AdapterError, StoreAdapter},
+    store::{adapter::AdapterError, StoreError},
     StdError,
 };
 
+use crate::VerificationKeyStorer;
+
 /// SignerRegistration record is the representation of a stored signer_registration.
 #[derive(Debug, PartialEq, Clone)]
 pub struct SignerRegistrationRecord {
@@ -469,141 +465,9 @@ impl VerificationKeyStorer for SignerRegistrationStore {
     }
 }
 
-/// Service to deal with signer_registration (read & write).
-pub struct SignerRegistrationStoreAdapter {
-    connection: Arc<Mutex<Connection>>,
-}
-
-impl SignerRegistrationStoreAdapter {
-    /// Create a new SignerRegistrationStoreAdapter service
-    pub fn new(connection: Arc<Mutex<Connection>>) -> Self {
-        Self { connection }
-    }
-}
-
-#[async_trait]
-impl StoreAdapter for SignerRegistrationStoreAdapter {
-    type Key = Epoch;
-    type Record = HashMap<PartyId, SignerWithStake>;
-
-    async fn store_record(
-        &mut self,
-        key: &Self::Key,
-        record: &Self::Record,
-    ) -> Result<(), AdapterError> {
-        let connection = &*self.connection.lock().await;
-        let provider = InsertOrReplaceSignerRegistrationRecordProvider::new(connection);
-        connection
-            .execute("begin transaction")
-            .map_err(|e| AdapterError::QueryError(e.into()))?;
-
-        for signer_with_stake in record.values() {
-            let _signer_registration_record = provider
-                .persist(SignerRegistrationRecord::from_signer_with_stake(
-                    signer_with_stake.to_owned(),
-                    *key,
-                ))
-                .map_err(|e| AdapterError::GeneralError(format!("{e}")))?;
-        }
-
-        connection
-            .execute("commit transaction")
-            .map_err(|e| AdapterError::QueryError(e.into()))?;
-
-        Ok(())
-    }
-
-    async fn get_record(&self, key: &Self::Key) -> Result<Option<Self::Record>, AdapterError> {
-        let connection = &*self.connection.lock().await;
-        let provider = SignerRegistrationRecordProvider::new(connection);
-        let cursor = provider
-            .get_by_epoch(key)
-            .map_err(|e| AdapterError::GeneralError(format!("{e}")))?;
-        let mut signer_with_stakes = HashMap::new();
-        for signer_registration_record in cursor {
-            signer_with_stakes.insert(
-                signer_registration_record.signer_id.to_string(),
-                signer_registration_record.into(),
-            );
-        }
-        if signer_with_stakes.is_empty() {
-            Ok(None)
-        } else {
-            Ok(Some(signer_with_stakes))
-        }
-    }
-
-    async fn record_exists(&self, key: &Self::Key) -> Result<bool, AdapterError> {
-        Ok(self.get_record(key).await?.is_some())
-    }
-
-    async fn get_last_n_records(
-        &self,
-        how_many: usize,
-    ) -> Result<Vec<(Self::Key, Self::Record)>, AdapterError> {
-        let connection = &*self.connection.lock().await;
-        let provider = SignerRegistrationRecordProvider::new(connection);
-        let cursor = provider
-            .get_all()
-            .map_err(|e| AdapterError::GeneralError(format!("{e}")))?
-            .collect::<Vec<_>>()
-            .into_iter()
-            .rev();
-        let signer_with_stake_by_epoch: BTreeMap<Self::Key, Self::Record> = cursor.fold(
-            BTreeMap::<Self::Key, Self::Record>::new(),
-            |mut acc, signer_registration_record| {
-                let epoch = signer_registration_record.epoch_setting_id;
-                let mut signer_with_stakes: Self::Record =
-                    if let Some(signer_with_stakes) = acc.get_mut(&epoch) {
-                        signer_with_stakes.to_owned()
-                    } else {
-                        HashMap::new()
-                    };
-                signer_with_stakes.insert(
-                    signer_registration_record.signer_id.to_string(),
-                    signer_registration_record.into(),
-                );
-                acc.insert(epoch, signer_with_stakes);
-                acc
-            },
-        );
-        Ok(signer_with_stake_by_epoch
-            .into_iter()
-            .rev()
-            .take(how_many)
-            .collect())
-    }
-
-    async fn remove(&mut self, key: &Self::Key) -> Result<Option<Self::Record>, AdapterError> {
-        let connection = &*self.connection.lock().await;
-        let provider = DeleteSignerRegistrationRecordProvider::new(connection);
-        let cursor = provider
-            .delete(*key)
-            .map_err(|e| AdapterError::GeneralError(format!("{e}")))?;
-        let mut signer_with_stakes = HashMap::new();
-        for signer_registration_record in cursor {
-            signer_with_stakes.insert(
-                signer_registration_record.signer_id.to_string(),
-                signer_registration_record.into(),
-            );
-        }
-
-        if signer_with_stakes.is_empty() {
-            Ok(None)
-        } else {
-            Ok(Some(signer_with_stakes))
-        }
-    }
-
-    async fn get_iter(&self) -> Result<Box<dyn Iterator<Item = Self::Record> + '_>, AdapterError> {
-        let records = self.get_last_n_records(usize::MAX).await?;
-        Ok(Box::new(records.into_iter().map(|(_k, v)| v)))
-    }
-}
-
 #[cfg(test)]
 mod tests {
-    use std::collections::{BTreeMap, HashMap};
+    use std::collections::HashMap;
 
     use mithril_common::test_utils::MithrilFixtureBuilder;
 
@@ -939,66 +803,6 @@ mod tests {
         }
     }
 
-    #[tokio::test]
-    async fn test_store_adapter() {
-        let fixture = MithrilFixtureBuilder::default().with_signers(5).build();
-        let signer_with_stakes = fixture.signers_with_stake();
-        let signer_with_stakes_by_epoch: Vec<(Epoch, HashMap<PartyId, SignerWithStake>)> = (0..5)
-            .map(|e| {
-                (
-                    Epoch(e),
-                    signer_with_stakes
-                        .clone()
-                        .into_iter()
-                        .map(|s| (s.party_id.to_owned(), s))
-                        .collect(),
-                )
-            })
-            .collect();
-
-        let connection = Connection::open(":memory:").unwrap();
-        setup_signer_registration_db(&connection, Vec::new()).unwrap();
-
-        let mut signer_registration_store_adapter =
-            SignerRegistrationStoreAdapter::new(Arc::new(Mutex::new(connection)));
-
-        for (epoch, signer_with_stakes) in &signer_with_stakes_by_epoch {
-            assert!(signer_registration_store_adapter
-                .store_record(epoch, signer_with_stakes)
-                .await
-                .is_ok());
-        }
-
-        for (epoch, signer_with_stakes) in &signer_with_stakes_by_epoch {
-            assert!(signer_registration_store_adapter
-                .record_exists(epoch)
-                .await
-                .unwrap());
-            assert_eq!(
-                Some(signer_with_stakes.to_owned()),
-                signer_registration_store_adapter
-                    .get_record(epoch)
-                    .await
-                    .unwrap()
-            );
-        }
-        assert_eq!(
-            signer_with_stakes_by_epoch
-                .clone()
-                .into_iter()
-                .map(|(k, v)| (k, BTreeMap::from_iter(v.into_iter())))
-                .collect::<Vec<(Epoch, BTreeMap<PartyId, SignerWithStake>)>>(),
-            signer_registration_store_adapter
-                .get_last_n_records(signer_with_stakes_by_epoch.len())
-                .await
-                .unwrap()
-                .into_iter()
-                .rev()
-                .map(|(k, v)| (k, BTreeMap::from_iter(v.into_iter())))
-                .collect::<Vec<(Epoch, BTreeMap<PartyId, SignerWithStake>)>>()
-        )
-    }
-
     pub fn init_signer_registration_store(
         initial_data: Vec<(Epoch, HashMap<PartyId, SignerWithStake>)>,
         retention_limit: Option<usize>,

mithril-aggregator/src/dependency_injection/builder.rs

@@ -41,10 +41,13 @@ use crate::{
     },
     certifier_service::{CertifierService, MithrilCertifierService},
     configuration::ExecutionEnvironment,
-    database::provider::{
-        CertificateRepository, CertificateStoreAdapter, EpochSettingStore, OpenMessageRepository,
-        SignedEntityStoreAdapter, SignedEntityStorer, SignerRegistrationStoreAdapter, SignerStore,
-        SingleSignatureRepository, StakePoolStore,
+    database::{
+        provider::SignerRegistrationStore,
+        provider::{
+            CertificateRepository, CertificateStoreAdapter, EpochSettingStore,
+            OpenMessageRepository, SignedEntityStoreAdapter, SignedEntityStorer, SignerStore,
+            SingleSignatureRepository, StakePoolStore,
+        },
     },
     event_store::{EventMessage, EventStore, TransmitterService},
     http_server::routes::router,
@@ -57,7 +60,7 @@ use crate::{
     CertificateStore, Configuration, DependencyManager, DumbSnapshotUploader, DumbSnapshotter,
     GzipSnapshotter, LocalSnapshotUploader, MithrilSignerRegisterer, MultiSigner, MultiSignerImpl,
     ProtocolParametersStore, ProtocolParametersStorer, RemoteSnapshotUploader, SnapshotUploader,
-    SnapshotUploaderType, Snapshotter, VerificationKeyStore, VerificationKeyStorer,
+    SnapshotUploaderType, Snapshotter, VerificationKeyStorer,
 };
 
 use super::{DependenciesBuilderError, Result};
@@ -399,11 +402,9 @@ impl DependenciesBuilder {
     }
 
     async fn build_verification_key_store(&mut self) -> Result<Arc<dyn VerificationKeyStorer>> {
-        Ok(Arc::new(VerificationKeyStore::new(
-            Box::new(SignerRegistrationStoreAdapter::new(
-                self.get_sqlite_connection().await?,
-            )),
-            self.configuration.store_retention_limit,
+        Ok(Arc::new(SignerRegistrationStore::new(
+            self.get_sqlite_connection().await?,
+            self.configuration.store_retention_limit.map(|l| l as u64),
         )))
     }