add execute state for transaction payload export

welbon · welbon · commit bb5f1567c9ca · 2024-02-22T15:26:04.000+08:00
diff --git a/cmd/db-exporter/src/command_progress.rs b/cmd/db-exporter/src/command_progress.rs
@@ -3,13 +3,15 @@ use indicatif::{ProgressBar, ProgressStyle};
 use rayon::prelude::*;
 use starcoin_chain::{BlockChain, ChainReader};
 use starcoin_config::ChainNetwork;
+use starcoin_crypto::HashValue;
 use starcoin_genesis::Genesis;
 use starcoin_storage::cache_storage::CacheStorage;
 use starcoin_storage::db_storage::DBStorage;
 use starcoin_storage::storage::StorageInstance;
 use starcoin_storage::{Storage, StorageVersion};
 use starcoin_types::block::{Block, BlockNumber};
 use starcoin_vm_types::language_storage::TypeTag;
+use starcoin_vm_types::vm_status::KeptVMStatus;
 use std::io::{Seek, SeekFrom};
 use std::sync::Arc;
 use std::{
@@ -127,6 +129,10 @@ impl ParallelCommandBlockReader for ParallelCommandReadBodyFromExportLine {
             })
             .collect::<Result<Vec<Block>, _>>()?)
     }
+
+    fn query_txn_exec_state(&self, _txn_hash: HashValue) -> String {
+        "OK".to_string()
+    }
 }
 
 pub struct ParallelCommandReadBlockFromDB {
@@ -234,8 +240,21 @@ impl ParallelCommandBlockReader for ParallelCommandReadBlockFromDB {
                     self.chain.get_block_by_number(*num).ok().flatten()
                 }
             })
-            .collect::<Vec<Block>>()
-        )
+            .collect::<Vec<Block>>())
+    }
+
+    fn query_txn_exec_state(&self, txn_hash: HashValue) -> String {
+        let txn = self
+            .chain
+            .get_transaction_info(txn_hash)
+            .expect("Query failed!");
+        match txn {
+            Some(info) => match info.status {
+                KeptVMStatus::Executed => "OK".to_string(),
+                _ => "FALIED".to_string(),
+            },
+            None => "CANT_FOUND_TXN".to_string(),
+        }
     }
 }
 
@@ -321,7 +340,7 @@ impl ParallelCommandProgress {
                 item_vec
                     .into_iter()
                     .map(|item| {
-                        let (succeed, failed) = item.execute(command);
+                        let (succeed, failed) = item.execute(self.block_reader.as_ref(), command);
                         progress_bar.inc(1);
                         CommandResult::new(succeed, failed.len())
                     })
@@ -355,7 +374,11 @@ impl ParallelCommandProgress {
 }
 
 pub trait ParallelCommand<CommandT, ErrorT> {
-    fn execute(&self, cmd: &CommandT) -> (usize, Vec<ErrorT>);
+    fn execute(
+        &self,
+        block_reader: &dyn ParallelCommandBlockReader,
+        cmd: &CommandT,
+    ) -> (usize, Vec<ErrorT>);
 
     fn matched(&self, filter: &Option<ParallelCommandFilter>) -> bool;
 }
@@ -365,7 +388,8 @@ pub trait ParallelCommandObserver {
     fn after_progress(&self) -> Result<()>;
 }
 
-pub trait ParallelCommandBlockReader {
+pub trait ParallelCommandBlockReader: Sync + Send {
     fn get_progress_interval(&self) -> u64;
     fn read(&self, load_bar: &ProgressBar) -> Result<Vec<Block>>;
+    fn query_txn_exec_state(&self, txn_hash: HashValue) -> String;
 }
diff --git a/cmd/db-exporter/src/commands/decode_payload.rs b/cmd/db-exporter/src/commands/decode_payload.rs
@@ -2,8 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::command_progress::{
-    ParallelCommand, ParallelCommandFilter, ParallelCommandObserver, ParallelCommandProgress,
-    ParallelCommandReadBlockFromDB,
+    ParallelCommand, ParallelCommandBlockReader, ParallelCommandFilter, ParallelCommandObserver,
+    ParallelCommandProgress, ParallelCommandReadBlockFromDB,
 };
 use anyhow::Result;
 use chrono::{DateTime, Utc};
@@ -104,6 +104,7 @@ pub struct CSVHeaders {
     func_name: String,
     ty_args: String,
     args: String,
+    execute_result: String,
     timestamp: u64,
     date_time: String,
 }
@@ -135,7 +136,11 @@ fn timestamp_to_datetime(timestamp: u64) -> String {
 }
 
 impl ParallelCommand<CommandDecodePayload, DecodePayloadCommandError> for Block {
-    fn execute(&self, command: &CommandDecodePayload) -> (usize, Vec<DecodePayloadCommandError>) {
+    fn execute(
+        &self,
+        block_reader: &dyn ParallelCommandBlockReader,
+        command: &CommandDecodePayload,
+    ) -> (usize, Vec<DecodePayloadCommandError>) {
         // let errors = vec![];
         // let mut success_module_size = 0;
 
@@ -152,6 +157,8 @@ impl ParallelCommand<CommandDecodePayload, DecodePayloadCommandError> for Block
                 starcoin_abi_decoder::decode_txn_payload(&statedb, txn.payload())
                     .expect("Decode transaction payload failed!");
 
+            let execute_result = block_reader.query_txn_exec_state(txn.hash());
+
             let mut writer = command.writer_mutex.lock().unwrap();
             match decoded_txn_payload {
                 DecodedTransactionPayload::ScriptFunction(payload) => writer
@@ -164,29 +171,41 @@ impl ParallelCommand<CommandDecodePayload, DecodePayloadCommandError> for Block
                         ty_args: payload
                             .ty_args
                             .iter()
-                            .map(|a| a.to_string())
+                            .map(|a| a.to_string().trim_matches('"').to_string())
                             .collect::<Vec<_>>()
                             .join("|"),
                         args: payload
                             .args
                             .iter()
-                            .map(|a| a.0.to_string())
+                            .map(|a| a.0.to_string().trim_matches('"').to_string())
                             .collect::<Vec<_>>()
                             .join("|"),
                         timestamp,
+                        execute_result,
                         date_time: formatted_date.clone(),
                     })
                     .expect("Write into CSV failed!"),
-                DecodedTransactionPayload::Script(_) => writer
+                DecodedTransactionPayload::Script(script) => writer
                     .serialize(CSVHeaders {
                         block_num: block_num.clone(),
                         txn_hash: txn.hash().to_string(),
                         txn_type: String::from("Script"),
                         signer,
-                        func_name: "".to_string(),
-                        ty_args: "".to_string(),
-                        args: "".to_string(),
+                        func_name: String::from(""),
+                        ty_args: script
+                            .ty_args
+                            .iter()
+                            .map(|a| a.to_string())
+                            .collect::<Vec<_>>()
+                            .join("|"),
+                        args: script
+                            .args
+                            .iter()
+                            .map(|a| a.0.to_string().trim_matches('"').to_string())
+                            .collect::<Vec<_>>()
+                            .join("|"),
                         timestamp,
+                        execute_result,
                         date_time: formatted_date.clone(),
                     })
                     .expect("Write into CSV failed!"),
@@ -200,6 +219,7 @@ impl ParallelCommand<CommandDecodePayload, DecodePayloadCommandError> for Block
                         ty_args: "".to_string(),
                         args: "".to_string(),
                         timestamp,
+                        execute_result,
                         date_time: formatted_date.clone(),
                     })
                     .expect("Write into CSV failed!"),
@@ -219,21 +239,17 @@ impl ParallelCommand<CommandDecodePayload, DecodePayloadCommandError> for Block
         };
 
         match filters {
-            Some(filter) => {
-                self.transactions().iter().any(|txn| {
-                    match txn.payload() {
-                        TransactionPayload::ScriptFunction(payload) => {
-                            filter.match_signer(&txn.sender().to_string())
-                                && filter.match_func_name(payload.function().as_str())
-                                && filter.match_ty_args(payload.ty_args())
-                                && filter.match_args(payload.args())
-                        },
-                        TransactionPayload::Script(_) | TransactionPayload::Package(_) => {
-                            filter.match_signer(&txn.sender().to_string())
-                        },
-                    }
-                })
-            },
+            Some(filter) => self.transactions().iter().any(|txn| match txn.payload() {
+                TransactionPayload::ScriptFunction(payload) => {
+                    filter.match_signer(&txn.sender().to_string())
+                        && filter.match_func_name(payload.function().as_str())
+                        && filter.match_ty_args(payload.ty_args())
+                        && filter.match_args(payload.args())
+                }
+                TransactionPayload::Script(_) | TransactionPayload::Package(_) => {
+                    filter.match_signer(&txn.sender().to_string())
+                }
+            }),
             None => true,
         }
     }
@@ -291,7 +307,7 @@ pub fn do_decode_payload(
 #[test]
 pub fn test_decode_payload() -> Result<()> {
     let input = PathBuf::from("/Users/bobong/.starcoin/main");
-    let output = PathBuf::from("/Users/bobong/Downloads/STC-DB-mainnet/output.csv");
+    let output = PathBuf::from("/Users/bobong/Downloads/unit-output.csv");
 
     // do_decode_payload(Main, input.clone(), output.clone(), None, None, None)?;
 
diff --git a/cmd/db-exporter/src/commands/mod.rs b/cmd/db-exporter/src/commands/mod.rs
@@ -0,0 +1,3 @@
+pub mod decode_payload;
+pub mod verify_header;
+pub mod verify_module;
diff --git a/cmd/db-exporter/src/commands/verify_header.rs b/cmd/db-exporter/src/commands/verify_header.rs
@@ -7,7 +7,7 @@ use std::path::PathBuf;
 use std::sync::Arc;
 
 use crate::command_progress::{
-    ParallelCommand, ParallelCommandFilter, ParallelCommandProgress,
+    ParallelCommand, ParallelCommandBlockReader, ParallelCommandFilter, ParallelCommandProgress,
     ParallelCommandReadBodyFromExportLine,
 };
 use starcoin_types::block::Block;
@@ -43,7 +43,11 @@ pub fn verify_header_via_export_file(path: PathBuf, batch_size: usize) -> anyhow
 }
 
 impl ParallelCommand<VerifyHeaderCmdType, VerifyHeaderError> for Block {
-    fn execute(&self, _cmd: &VerifyHeaderCmdType) -> (usize, Vec<VerifyHeaderError>) {
+    fn execute(
+        &self,
+        _reader: &dyn ParallelCommandBlockReader,
+        _cmd: &VerifyHeaderCmdType,
+    ) -> (usize, Vec<VerifyHeaderError>) {
         let ret = G_CRYPTONIGHT.verify_header_difficulty(self.header.difficulty(), &self.header);
         match ret {
             Ok(_) => (1, vec![]),
diff --git a/cmd/db-exporter/src/commands/verify_module.rs b/cmd/db-exporter/src/commands/verify_module.rs
@@ -1,15 +1,14 @@
+use crate::command_progress::{
+    ParallelCommand, ParallelCommandBlockReader, ParallelCommandFilter, ParallelCommandProgress,
+    ParallelCommandReadBodyFromExportLine,
+};
 use clap::Parser;
 use move_binary_format::errors::Location;
 use starcoin_crypto::HashValue;
 use starcoin_types::{block::Block, transaction::TransactionPayload};
 use starcoin_vm_types::{errors::VMError, file_format::CompiledModule};
 use std::sync::Arc;
 use std::{fmt::Debug, path::PathBuf};
-//use starcoin_accumulator::node::AccumulatorStoreType::Block;
-use crate::command_progress::{
-    ParallelCommand, ParallelCommandFilter, ParallelCommandProgress,
-    ParallelCommandReadBodyFromExportLine,
-};
 
 #[derive(Debug, Parser)]
 #[clap(
@@ -32,7 +31,11 @@ pub struct VerifyModuleError {
 pub struct VerifyModulesType;
 
 impl ParallelCommand<VerifyModulesType, VerifyModuleError> for Block {
-    fn execute(&self, _cmd: &VerifyModulesType) -> (usize, Vec<VerifyModuleError>) {
+    fn execute(
+        &self,
+        _reader: &dyn ParallelCommandBlockReader,
+        _cmd: &VerifyModulesType,
+    ) -> (usize, Vec<VerifyModuleError>) {
         let mut errors = vec![];
         let mut success_modules = 0;
         let block = self;
diff --git a/cmd/db-exporter/src/lib.rs b/cmd/db-exporter/src/lib.rs
@@ -1,7 +1,5 @@
 // Copyright (c) The Starcoin Core Contributors
 // SPDX-License-Identifier: Apache-2.0
 
-pub mod command_decode_payload;
 pub mod command_progress;
-pub mod verify_header;
-pub mod verify_module;
+pub mod commands;
diff --git a/cmd/db-exporter/src/main.rs b/cmd/db-exporter/src/main.rs
@@ -5,11 +5,11 @@ use anyhow::{bail, format_err, Result};
 use bcs_ext::{BCSCodec, Sample};
 use clap::{IntoApp, Parser};
 use csv::Writer;
-use db_exporter::{
-    command_decode_payload::{do_decode_payload_command, DecodePayloadCommandOptions},
-    verify_header::{verify_header_via_export_file, VerifyHeaderOptions},
-    verify_module::{verify_modules_via_export_file, VerifyModuleOptions},
-};
+// use db_exporter::{
+//     decode_payload::{do_decode_payload_command, DecodePayloadCommandOptions},
+//     verify_header::{verify_header_via_export_file, VerifyHeaderOptions},
+//     verify_module::{verify_modules_via_export_file, VerifyModuleOptions},
+// };
 use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
 use serde::{ser::SerializeMap, Serialize, Serializer};
 use starcoin_account_api::AccountInfo;
@@ -70,6 +70,12 @@ use std::{
     time::SystemTime,
 };
 
+use db_exporter::commands::{
+    decode_payload::{do_decode_payload_command, DecodePayloadCommandOptions},
+    verify_header::{verify_header_via_export_file, VerifyHeaderOptions},
+    verify_module::{verify_modules_via_export_file, VerifyModuleOptions},
+};
+
 const BLOCK_GAP: u64 = 1000;
 const BACK_SIZE: u64 = 10000;
 const SNAP_GAP: u64 = 128;
@@ -1887,6 +1893,7 @@ pub fn export_resource(
         let now2 = Instant::now();
         for (k, v) in resource_set.iter() {
             let struct_tag = StructTag::decode(k.as_slice())?;
+            println!("struct_tag: {:?}", struct_tag.to_string());
             if struct_tag == resource_struct_tag {
                 let annotated_struct =
                     value_annotator.view_struct(resource_struct_tag.clone(), v.as_slice())?;

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+pub mod decode_payload;`
	`2`	`+pub mod verify_header;`
	`3`	`+pub mod verify_module;`