Rename TransactionParser to BlockScanner

Since we will change it's main method signature to retrieve a list of
blocks instead of a list of transactions.

Author: Alenar

mithril-aggregator/src/dependency_injection/builder.rs

@@ -13,7 +13,7 @@ use warp::Filter;
 
 use mithril_common::{
     api_version::APIVersionProvider,
-    cardano_transaction_parser::{CardanoTransactionParser, TransactionParser},
+    cardano_block_scanner::{BlockScanner, CardanoBlockScanner},
     certificate_chain::{CertificateVerifier, MithrilCertificateVerifier},
     chain_observer::{CardanoCliRunner, ChainObserver, ChainObserverBuilder, FakeObserver},
     crypto_helper::{
@@ -137,7 +137,7 @@ pub struct DependenciesBuilder {
     pub transaction_store: Option<Arc<dyn TransactionStore>>,
 
     /// Cardano transactions parser.
-    pub transaction_parser: Option<Arc<dyn TransactionParser>>,
+    pub block_scanner: Option<Arc<dyn BlockScanner>>,
 
     /// Immutable file digester service.
     pub immutable_digester: Option<Arc<dyn ImmutableDigester>>,
@@ -233,7 +233,7 @@ impl DependenciesBuilder {
             cardano_cli_runner: None,
             chain_observer: None,
             time_point_provider: None,
-            transaction_parser: None,
+            block_scanner: None,
             transaction_repository: None,
             transaction_store: None,
             immutable_digester: None,
@@ -713,24 +713,24 @@ impl DependenciesBuilder {
         Ok(self.transaction_store.as_ref().cloned().unwrap())
     }
 
-    async fn build_transaction_parser(&mut self) -> Result<Arc<dyn TransactionParser>> {
-        let transaction_parser = CardanoTransactionParser::new(
+    async fn build_block_scanner(&mut self) -> Result<Arc<dyn BlockScanner>> {
+        let block_scanner = CardanoBlockScanner::new(
             self.get_logger().await?,
             self.configuration
                 .get_network()?
                 .compute_allow_unparsable_block(self.configuration.allow_unparsable_block)?,
         );
 
-        Ok(Arc::new(transaction_parser))
+        Ok(Arc::new(block_scanner))
     }
 
     /// Transaction parser.
-    pub async fn get_transaction_parser(&mut self) -> Result<Arc<dyn TransactionParser>> {
-        if self.transaction_parser.is_none() {
-            self.transaction_parser = Some(self.build_transaction_parser().await?);
+    pub async fn get_block_scanner(&mut self) -> Result<Arc<dyn BlockScanner>> {
+        if self.block_scanner.is_none() {
+            self.block_scanner = Some(self.build_block_scanner().await?);
         }
 
-        Ok(self.transaction_parser.as_ref().cloned().unwrap())
+        Ok(self.block_scanner.as_ref().cloned().unwrap())
     }
 
     async fn build_immutable_digester(&mut self) -> Result<Arc<dyn ImmutableDigester>> {
@@ -1055,7 +1055,7 @@ impl DependenciesBuilder {
             self.get_logger().await?,
         ));
         let transactions_importer = Arc::new(CardanoTransactionsImporter::new(
-            self.get_transaction_parser().await?,
+            self.get_block_scanner().await?,
             self.get_transaction_store().await?,
             &self.configuration.db_directory,
             // Rescan the last immutable when importing transactions, it may have been partially imported
@@ -1198,7 +1198,7 @@ impl DependenciesBuilder {
             signed_entity_storer: self.get_signed_entity_storer().await?,
             signer_getter: self.get_signer_store().await?,
             message_service: self.get_message_service().await?,
-            transaction_parser: self.get_transaction_parser().await?,
+            transaction_parser: self.get_block_scanner().await?,
             transaction_store: self.get_transaction_store().await?,
             prover_service: self.get_prover_service().await?,
         };

mithril-aggregator/src/dependency_injection/containers.rs

@@ -3,7 +3,7 @@ use tokio::sync::RwLock;
 
 use mithril_common::{
     api_version::APIVersionProvider,
-    cardano_transaction_parser::TransactionParser,
+    cardano_block_scanner::BlockScanner,
     certificate_chain::CertificateVerifier,
     chain_observer::ChainObserver,
     crypto_helper::ProtocolGenesisVerifier,
@@ -88,7 +88,7 @@ pub struct DependencyContainer {
     pub transaction_store: Arc<dyn TransactionStore>,
 
     /// Cardano transactions parser.
-    pub transaction_parser: Arc<dyn TransactionParser>,
+    pub transaction_parser: Arc<dyn BlockScanner>,
 
     /// Immutable file observer service.
     pub immutable_file_observer: Arc<dyn ImmutableFileObserver>,

mithril-aggregator/src/services/cardano_transactions_importer.rs

@@ -6,7 +6,7 @@ use async_trait::async_trait;
 use mockall::automock;
 use slog::{debug, Logger};
 
-use mithril_common::cardano_transaction_parser::TransactionParser;
+use mithril_common::cardano_block_scanner::BlockScanner;
 use mithril_common::entities::{CardanoTransaction, ImmutableFileNumber};
 use mithril_common::signable_builder::TransactionsImporter;
 use mithril_common::StdResult;
@@ -30,7 +30,7 @@ pub trait TransactionStore: Send + Sync {
 
 /// Import and store [CardanoTransaction].
 pub struct CardanoTransactionsImporter {
-    transaction_parser: Arc<dyn TransactionParser>,
+    block_scanner: Arc<dyn BlockScanner>,
     transaction_store: Arc<dyn TransactionStore>,
     logger: Logger,
     rescan_offset: Option<usize>,
@@ -44,14 +44,14 @@ impl CardanoTransactionsImporter {
     /// immutables starting after the highest immutable known in the store.
     /// This is useful when one of the last immutable was not full scanned.
     pub fn new(
-        transaction_parser: Arc<dyn TransactionParser>,
+        block_scanner: Arc<dyn BlockScanner>,
         transaction_store: Arc<dyn TransactionStore>,
         dirpath: &Path,
         rescan_offset: Option<usize>,
         logger: Logger,
     ) -> Self {
         Self {
-            transaction_parser,
+            block_scanner,
             transaction_store,
             logger,
             rescan_offset,
@@ -79,10 +79,7 @@ impl CardanoTransactionsImporter {
             return Ok(());
         }
 
-        let parsed_transactions = self
-            .transaction_parser
-            .parse(&self.dirpath, from, until)
-            .await?;
+        let parsed_transactions = self.block_scanner.parse(&self.dirpath, from, until).await?;
         debug!(
             self.logger,
             "TransactionsImporter retrieved '{}' Cardano transactions between immutables '{}' and '{until}'",
@@ -123,10 +120,10 @@ mod tests {
     use super::*;
 
     mock! {
-        pub TransactionParserImpl { }
+        pub BlockScannerImpl { }
 
         #[async_trait]
-        impl TransactionParser for TransactionParserImpl {
+        impl BlockScanner for BlockScannerImpl {
             async fn parse(
               &self,
               dirpath: &Path,
@@ -137,19 +134,19 @@ mod tests {
     }
 
     fn build_importer(
-        parser_mock_config: &dyn Fn(&mut MockTransactionParserImpl),
+        scanner_mock_config: &dyn Fn(&mut MockBlockScannerImpl),
         store_mock_config: &dyn Fn(&mut MockTransactionStore),
     ) -> CardanoTransactionsImporter {
         let db_path = Path::new("");
-        let mut parser = MockTransactionParserImpl::new();
-        parser_mock_config(&mut parser);
+        let mut scanner = MockBlockScannerImpl::new();
+        scanner_mock_config(&mut scanner);
 
         let mut store = MockTransactionStore::new();
         store.expect_get_up_to().returning(|_| Ok(vec![]));
         store_mock_config(&mut store);
 
         CardanoTransactionsImporter::new(
-            Arc::new(parser),
+            Arc::new(scanner),
             Arc::new(store),
             db_path,
             None,
@@ -168,9 +165,9 @@ mod tests {
         let up_to_beacon = 12;
 
         let importer = build_importer(
-            &|parser_mock| {
+            &|scanner_mock| {
                 let parsed_transactions = transactions.clone();
-                parser_mock
+                scanner_mock
                     .expect_parse()
                     .withf(move |_, from, until| from.is_none() && until == &up_to_beacon)
                     .return_once(move |_, _, _| Ok(parsed_transactions));
@@ -199,8 +196,8 @@ mod tests {
         let up_to_beacon = 12;
 
         let importer = build_importer(
-            &|parser_mock| {
-                parser_mock.expect_parse().never();
+            &|scanner_mock| {
+                scanner_mock.expect_parse().never();
             },
             &|store_mock| {
                 store_mock
@@ -227,9 +224,9 @@ mod tests {
         let up_to_beacon = 14;
 
         let importer = build_importer(
-            &|parser_mock| {
+            &|scanner_mock| {
                 let parsed_transactions = transactions[2..=3].to_vec();
-                parser_mock
+                scanner_mock
                     .expect_parse()
                     .withf(move |_, from, until| from == &Some(13) && until == &up_to_beacon)
                     .return_once(move |_, _, _| Ok(parsed_transactions));
@@ -265,13 +262,13 @@ mod tests {
         let importer = {
             let connection = cardano_tx_db_connection().unwrap();
             let parsed_transactions = transactions.clone();
-            let mut parser = MockTransactionParserImpl::new();
-            parser
+            let mut scanner = MockBlockScannerImpl::new();
+            scanner
                 .expect_parse()
                 .return_once(move |_, _, _| Ok(parsed_transactions));
 
             CardanoTransactionsImporter::new(
-                Arc::new(parser),
+                Arc::new(scanner),
                 Arc::new(CardanoTransactionRepository::new(Arc::new(connection))),
                 Path::new(""),
                 None,
@@ -305,7 +302,7 @@ mod tests {
                 .returning(move || Ok(Some(highest_stored_beacon)));
 
             CardanoTransactionsImporter::new(
-                Arc::new(MockTransactionParserImpl::new()),
+                Arc::new(MockBlockScannerImpl::new()),
                 Arc::new(store),
                 Path::new(""),
                 Some(rescan_offset as usize),