Merge pull request #720 from input-output-hk/ensemble/709/era_reader

add era reader

Author: ghubertpalo

docs/root/mithril/mithril-network/images/signer-runtime.jpg

@@ -15,9 +15,9 @@ use mithril_common::{
         CardanoImmutableDigester, ImmutableFileSystemObserver,
     },
     entities::{Epoch, HexEncodedGenesisSecretKey},
-    era::{EraChecker, SupportedEra},
+    era::{adapters::EraReaderBootstrapAdapter, EraChecker, EraReader},
     store::{adapter::SQLiteAdapter, StakeStore},
-    BeaconProviderImpl,
+    BeaconProvider, BeaconProviderImpl,
 };
 
 use crate::{
@@ -399,8 +399,14 @@ impl ServeCommand {
         ));
 
         // TODO: use EraReader when it is implemented to retrieve current era
-        let current_era = SupportedEra::Thales;
-        let era_checker = Arc::new(EraChecker::new(current_era));
+        let era_reader = Arc::new(EraReader::new(Box::new(EraReaderBootstrapAdapter)));
+        let era_epoch_token = era_reader
+            .read_era_epoch_token(beacon_provider.get_current_beacon().await?.epoch)
+            .await?;
+        let era_checker = Arc::new(EraChecker::new(
+            era_epoch_token.get_current_supported_era()?,
+            era_epoch_token.get_current_epoch(),
+        ));
 
         // Init dependency manager
         let dependency_manager = DependencyManager {
@@ -424,6 +430,7 @@ impl ServeCommand {
             signer_registerer: signer_registerer.clone(),
             signer_registration_round_opener: signer_registerer.clone(),
             era_checker: era_checker.clone(),
+            era_reader: era_reader.clone(),
         };
         let dependency_manager = Arc::new(dependency_manager);
 

mithril-aggregator/src/command_args.rs

@@ -6,7 +6,7 @@ use mithril_common::{
     entities::{
         Certificate, Epoch, ProtocolParameters, Signer, SignerWithStake, StakeDistribution,
     },
-    era::EraChecker,
+    era::{EraChecker, EraReader},
     store::{StakeStore, StakeStorer},
     BeaconProvider,
 };
@@ -87,6 +87,9 @@ pub struct DependencyManager {
 
     /// Era checker service
     pub era_checker: Arc<EraChecker>,
+
+    /// Era reader service
+    pub era_reader: Arc<EraReader>,
 }
 
 #[doc(hidden)]
@@ -269,10 +272,10 @@ pub mod tests {
         chain_observer::FakeObserver,
         crypto_helper::{key_encode_hex, ProtocolGenesisSigner},
         digesters::{DumbImmutableDigester, DumbImmutableFileObserver},
-        era::{EraChecker, SupportedEra},
+        era::{adapters::EraReaderBootstrapAdapter, EraChecker, EraReader},
         store::{adapter::MemoryAdapter, StakeStore},
         test_utils::fake_data,
-        BeaconProviderImpl, CardanoNetwork,
+        BeaconProvider, BeaconProviderImpl, CardanoNetwork,
     };
     use std::{path::PathBuf, sync::Arc};
     use tokio::sync::RwLock;
@@ -347,7 +350,15 @@ pub mod tests {
             chain_observer.clone(),
             verification_key_store.clone(),
         ));
-        let era_checker = Arc::new(EraChecker::new(SupportedEra::dummy()));
+        let era_reader = Arc::new(EraReader::new(Box::new(EraReaderBootstrapAdapter)));
+        let era_epoch_token = era_reader
+            .read_era_epoch_token(beacon_provider.get_current_beacon().await.unwrap().epoch)
+            .await
+            .unwrap();
+        let era_checker = Arc::new(EraChecker::new(
+            era_epoch_token.get_current_supported_era().unwrap(),
+            era_epoch_token.get_current_epoch(),
+        ));
 
         let dependency_manager = DependencyManager {
             config,
@@ -370,6 +381,7 @@ pub mod tests {
             signer_registerer: signer_registerer.clone(),
             signer_registration_round_opener: signer_registerer,
             era_checker,
+            era_reader,
         };
 
         let config = AggregatorConfig::new(

mithril-aggregator/src/dependency.rs

@@ -147,6 +147,9 @@ pub trait AggregatorRunnerTrait: Sync + Send {
         ongoing_snapshot: &OngoingSnapshot,
         remote_locations: Vec<String>,
     ) -> Result<Snapshot, RuntimeError>;
+
+    /// Update the EraChecker with EraReader information.
+    async fn update_era_checker(&self, beacon: &Beacon) -> Result<(), RuntimeError>;
 }
 
 /// The runner responsibility is to expose a code API for the state machine. It
@@ -614,6 +617,25 @@ impl AggregatorRunnerTrait for AggregatorRunner {
 
         Ok(snapshot)
     }
+
+    async fn update_era_checker(&self, beacon: &Beacon) -> Result<(), RuntimeError> {
+        let token = self
+            .dependencies
+            .era_reader
+            .read_era_epoch_token(beacon.epoch)
+            .await
+            .map_err(|e| {
+                RuntimeError::General(format!("Could not get Era information ('{e}')").into())
+            })?;
+        self.dependencies.era_checker.change_era(
+            token.get_current_supported_era().map_err(|e| {
+                RuntimeError::General(format!("Could not update EraChecker service ('{e}')").into())
+            })?,
+            token.get_current_epoch(),
+        );
+
+        Ok(())
+    }
 }
 
 #[cfg(test)]
@@ -1148,4 +1170,19 @@ pub mod tests {
             ongoing_snapshot.get_file_path()
         );
     }
+
+    #[tokio::test]
+    async fn test_update_era_checker() {
+        let (deps, config) = initialize_dependencies().await;
+        let beacon_provider = deps.beacon_provider.clone();
+        let era_checker = deps.era_checker.clone();
+        let mut beacon = beacon_provider.get_current_beacon().await.unwrap();
+
+        assert_eq!(beacon.epoch, era_checker.current_epoch());
+        let runner = AggregatorRunner::new(config, Arc::new(deps));
+        beacon.epoch += 1;
+
+        runner.update_era_checker(&beacon).await.unwrap();
+        assert_eq!(beacon.epoch, era_checker.current_epoch());
+    }
 }

mithril-aggregator/src/runtime/runner.rs

@@ -222,6 +222,7 @@ impl AggregatorRuntime {
         if maybe_current_beacon.is_none() || maybe_current_beacon.unwrap().epoch < new_beacon.epoch
         {
             self.runner.close_signer_registration_round().await?;
+            self.runner.update_era_checker(&new_beacon).await?;
             self.runner.update_stake_distribution(&new_beacon).await?;
             self.runner
                 .open_signer_registration_round(&new_beacon)
@@ -388,6 +389,11 @@ mod tests {
             .expect_is_certificate_chain_valid()
             .once()
             .returning(|| Ok(false));
+        runner
+            .expect_update_era_checker()
+            .with(predicate::eq(fake_data::beacon()))
+            .once()
+            .returning(|_| Ok(()));
 
         let mut runtime = init_runtime(
             Some(AggregatorState::Idle(IdleState {
@@ -435,6 +441,11 @@ mod tests {
             .expect_is_certificate_chain_valid()
             .once()
             .returning(|| Ok(true));
+        runner
+            .expect_update_era_checker()
+            .with(predicate::eq(fake_data::beacon()))
+            .once()
+            .returning(|_| Ok(()));
 
         let mut runtime = init_runtime(
             Some(AggregatorState::Idle(IdleState {

mithril-aggregator/src/runtime/state_machine.rs

@@ -9,10 +9,11 @@ use mithril_common::chain_observer::FakeObserver;
 use mithril_common::crypto_helper::{key_encode_hex, ProtocolGenesisSigner};
 use mithril_common::digesters::{DumbImmutableDigester, DumbImmutableFileObserver};
 use mithril_common::entities::ProtocolParameters;
-use mithril_common::era::{EraChecker, SupportedEra};
+use mithril_common::era::EraReader;
+use mithril_common::era::{adapters::EraReaderBootstrapAdapter, EraChecker};
 use mithril_common::store::adapter::MemoryAdapter;
 use mithril_common::store::StakeStore;
-use mithril_common::{BeaconProviderImpl, CardanoNetwork};
+use mithril_common::{BeaconProvider, BeaconProviderImpl, CardanoNetwork};
 use std::path::PathBuf;
 use std::sync::Arc;
 use tokio::sync::RwLock;
@@ -91,7 +92,15 @@ pub async fn initialize_dependencies(
         chain_observer.clone(),
         verification_key_store.clone(),
     ));
-    let era_checker = Arc::new(EraChecker::new(SupportedEra::dummy()));
+    let era_reader = Arc::new(EraReader::new(Box::new(EraReaderBootstrapAdapter)));
+    let era_epoch_token = era_reader
+        .read_era_epoch_token(beacon_provider.get_current_beacon().await.unwrap().epoch)
+        .await
+        .unwrap();
+    let era_checker = Arc::new(EraChecker::new(
+        era_epoch_token.get_current_supported_era().unwrap(),
+        era_epoch_token.get_current_epoch(),
+    ));
 
     let dependency_manager = DependencyManager {
         config,
@@ -114,6 +123,7 @@ pub async fn initialize_dependencies(
         signer_registerer: signer_registerer.clone(),
         signer_registration_round_opener: signer_registerer,
         era_checker,
+        era_reader,
     };
 
     let config = AggregatorConfig::new(

mithril-aggregator/tests/test_extensions/dependency.rs

@@ -0,0 +1,43 @@
+use async_trait::async_trait;
+
+use crate::entities::Epoch;
+
+use super::super::{EraMarker, EraReaderAdapter, SupportedEra};
+
+/// The goal of the bootstrap adapter is to advertise for the first existing Era
+/// while it does not exist yet on any backend. This adapter is intended to be
+/// removed once Eras are effectively written in a backend.
+pub struct BootstrapAdapter;
+
+#[async_trait]
+impl EraReaderAdapter for BootstrapAdapter {
+    async fn read(&self) -> Result<Vec<EraMarker>, Box<dyn std::error::Error + Sync + Send>> {
+        Ok(vec![EraMarker::new(
+            &SupportedEra::Thales.to_string(),
+            Some(Epoch(1)),
+        )])
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::era::SupportedEra;
+
+    use super::*;
+
+    #[tokio::test]
+    async fn bootstrap_adapter() {
+        let adapter = BootstrapAdapter;
+
+        assert_eq!(
+            vec![EraMarker::new(
+                &SupportedEra::dummy().to_string(),
+                Some(Epoch(1))
+            )],
+            adapter
+                .read()
+                .await
+                .expect("bootstrap adapter shall never fail")
+        );
+    }
+}

mithril-common/src/era/adapters/bootstrap.rs

@@ -0,0 +1,65 @@
+use std::error::Error;
+
+use async_trait::async_trait;
+
+use super::super::{EraMarker, EraReaderAdapter};
+
+/// Dummy adapter is intended to be used in a test environment (end to end test)
+/// to simulate not yet activated Eras.
+#[derive(Default)]
+pub struct DummyAdapter {
+    markers: Vec<EraMarker>,
+}
+
+impl DummyAdapter {
+    /// Tells what markers should be sent back by the adapter.
+    pub fn set_markers(&mut self, markers: Vec<EraMarker>) {
+        self.markers = markers;
+    }
+}
+
+#[async_trait]
+impl EraReaderAdapter for DummyAdapter {
+    async fn read(&self) -> Result<Vec<EraMarker>, Box<dyn Error + Sync + Send>> {
+        Ok(self.markers.clone())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::entities::Epoch;
+
+    use super::super::super::SupportedEra;
+    use super::*;
+
+    #[tokio::test]
+    async fn empty_dummy_adapter() {
+        let adapter = DummyAdapter::default();
+
+        assert!(adapter
+            .read()
+            .await
+            .expect("dummy adapter shall not fail reading")
+            .is_empty());
+    }
+
+    #[tokio::test]
+    async fn dummy_adapter_output() {
+        let markers = vec![
+            EraMarker::new("one", Some(Epoch(1))),
+            EraMarker::new(&SupportedEra::dummy().to_string(), None),
+            EraMarker::new(&SupportedEra::dummy().to_string(), Some(Epoch(10))),
+        ];
+
+        let mut adapter = DummyAdapter::default();
+        adapter.set_markers(markers.clone());
+
+        assert_eq!(
+            markers,
+            adapter
+                .read()
+                .await
+                .expect("dummy adapter shall not fail reading")
+        );
+    }
+}

mithril-common/src/era/adapters/dummy.rs

@@ -0,0 +1,6 @@
+//! Module dedicated to EraReaderAdapter implementations.
+mod bootstrap;
+mod dummy;
+
+pub use bootstrap::BootstrapAdapter as EraReaderBootstrapAdapter;
+pub use dummy::DummyAdapter as EraReaderDummyAdapter;