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.

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,22 +713,22 @@ impl DependenciesBuilder {
         Ok(self.transaction_store.as_ref().cloned().unwrap())
     }
 
-    async fn build_transaction_parser(&mut self) -> Result<Arc<dyn TransactionParser>> {
+    async fn build_block_scanner(&mut self) -> Result<Arc<dyn BlockScanner>> {
         // TODO: 'allow_unparsable_block' parameter should be configurable
         let allow_unparsable_block = false;
-        let transaction_parser =
-            CardanoTransactionParser::new(self.get_logger().await?, allow_unparsable_block);
+        let block_scanner =
+            CardanoBlockScanner::new(self.get_logger().await?, 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>> {
@@ -1053,7 +1053,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
@@ -1196,7 +1196,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),

mithril-common/src/cardano_transaction_parser.rs → mithril-common/src/cardano_block_scanner.rs

@@ -22,17 +22,17 @@ use tokio::sync::RwLock;
 /// mod test {
 ///     use anyhow::anyhow;
 ///     use async_trait::async_trait;
-///     use mithril_common::cardano_transaction_parser::TransactionParser;
+///     use mithril_common::cardano_block_scanner::BlockScanner;
 ///     use mithril_common::entities::{CardanoDbBeacon, CardanoTransaction, ImmutableFileNumber};
 ///     use mithril_common::StdResult;
 ///     use mockall::mock;
 ///     use std::path::Path;
 ///
 ///     mock! {
-///         pub TransactionParserImpl { }
+///         pub BlockScannerImpl { }
 ///
 ///         #[async_trait]
-///         impl TransactionParser for TransactionParserImpl {
+///         impl BlockScanner for BlockScannerImpl {
 ///             async fn parse(
 ///               &self,
 ///               dirpath: &Path,
@@ -44,15 +44,15 @@ use tokio::sync::RwLock;
 ///
 ///     #[test]
 ///     fn test_mock() {
-///         let mut mock = MockTransactionParserImpl::new();
+///         let mut mock = MockBlockScannerImpl::new();
 ///         mock.expect_parse().return_once(|_, _| {
 ///             Err(anyhow!("parse error"))
 ///         });
 ///     }
 /// }
 /// ```
 #[async_trait]
-pub trait TransactionParser: Sync + Send {
+pub trait BlockScanner: Sync + Send {
     /// Parse the transactions
     async fn parse(
         &self,
@@ -63,11 +63,11 @@ pub trait TransactionParser: Sync + Send {
 }
 
 /// Dumb transaction parser
-pub struct DumbTransactionParser {
+pub struct DumbBlockScanner {
     transactions: RwLock<Vec<CardanoTransaction>>,
 }
 
-impl DumbTransactionParser {
+impl DumbBlockScanner {
     /// Factory
     pub fn new(transactions: Vec<CardanoTransaction>) -> Self {
         Self {
@@ -83,7 +83,7 @@ impl DumbTransactionParser {
 }
 
 #[async_trait]
-impl TransactionParser for DumbTransactionParser {
+impl BlockScanner for DumbBlockScanner {
     async fn parse(
         &self,
         _dirpath: &Path,
@@ -120,15 +120,15 @@ impl Block {
 }
 
 /// Cardano transaction parser
-pub struct CardanoTransactionParser {
+pub struct CardanoBlockScanner {
     logger: Logger,
     /// When set to true, no error is returned in case of unparsable block, and an error log is written instead.
     /// This can occur when the crate 'pallas-hardano' doesn't support some non final encoding for a Cardano era.
     /// This situation should only happen on the test networks and not on the mainnet.
     allow_unparsable_block: bool,
 }
 
-impl CardanoTransactionParser {
+impl CardanoBlockScanner {
     /// Factory
     pub fn new(logger: Logger, allow_unparsable_block: bool) -> Self {
         Self {
@@ -142,8 +142,7 @@ impl CardanoTransactionParser {
         &self,
         immutable_file: &ImmutableFile,
     ) -> StdResult<Vec<Block>> {
-        let cardano_blocks_reader =
-            CardanoTransactionParser::cardano_blocks_reader(immutable_file)?;
+        let cardano_blocks_reader = CardanoBlockScanner::cardano_blocks_reader(immutable_file)?;
 
         let mut blocks = Vec::new();
         for parsed_block in cardano_blocks_reader {
@@ -153,7 +152,7 @@ impl CardanoTransactionParser {
                     immutable_file.path
                 )
             })?;
-            match CardanoTransactionParser::convert_to_block(&block, immutable_file) {
+            match CardanoBlockScanner::convert_to_block(&block, immutable_file) {
                 Ok(convert_to_block) => {
                     blocks.push(convert_to_block);
                 }
@@ -200,7 +199,7 @@ impl CardanoTransactionParser {
 }
 
 #[async_trait]
-impl TransactionParser for CardanoTransactionParser {
+impl BlockScanner for CardanoBlockScanner {
     async fn parse(
         &self,
         dirpath: &Path,
@@ -285,7 +284,7 @@ mod tests {
         let until_immutable_file = 2;
         let tx_count: usize = immutable_files.iter().map(|(_, count)| *count).sum();
         let cardano_transaction_parser =
-            CardanoTransactionParser::new(Logger::root(slog::Discard, slog::o!()), false);
+            CardanoBlockScanner::new(Logger::root(slog::Discard, slog::o!()), false);
 
         let transactions = cardano_transaction_parser
             .parse(db_path, None, until_immutable_file)
@@ -305,7 +304,7 @@ mod tests {
         let until_immutable_file = 2;
         let tx_count: usize = immutable_files.iter().map(|(_, count)| *count).sum();
         let cardano_transaction_parser =
-            CardanoTransactionParser::new(Logger::root(slog::Discard, slog::o!()), false);
+            CardanoBlockScanner::new(Logger::root(slog::Discard, slog::o!()), false);
 
         let transactions = cardano_transaction_parser
             .parse(db_path, Some(2), until_immutable_file)
@@ -320,7 +319,7 @@ mod tests {
         let db_path = Path::new("../mithril-test-lab/test_data/parsing_error/immutable/");
         let until_immutable_file = 4831;
         let cardano_transaction_parser =
-            CardanoTransactionParser::new(Logger::root(slog::Discard, slog::o!()), false);
+            CardanoBlockScanner::new(Logger::root(slog::Discard, slog::o!()), false);
 
         let result = cardano_transaction_parser
             .parse(db_path, None, until_immutable_file)
@@ -341,7 +340,7 @@ mod tests {
         // We create a block to drop the logger and force a flush before we read the log file.
         {
             let cardano_transaction_parser =
-                CardanoTransactionParser::new(create_file_logger(&filepath), true);
+                CardanoBlockScanner::new(create_file_logger(&filepath), true);
 
             cardano_transaction_parser
                 .parse(db_path, None, until_immutable_file)
@@ -363,7 +362,7 @@ mod tests {
         let until_immutable_file = 1;
         let tx_count: usize = immutable_files.iter().map(|(_, count)| *count).sum();
         let cardano_transaction_parser =
-            CardanoTransactionParser::new(Logger::root(slog::Discard, slog::o!()), false);
+            CardanoBlockScanner::new(Logger::root(slog::Discard, slog::o!()), false);
 
         let transactions = cardano_transaction_parser
             .parse(db_path, None, until_immutable_file)