[all resource export] add subcommand for export

Author: welbon

cmd/resource-code-exporter/src/export.rs

@@ -1,19 +1,12 @@
 // Copyright (c) The Starcoin Core Contributors
 // SPDX-License-Identifier: Apache-2.0
 
-use clap::Parser;
 use starcoin_crypto::HashValue;
 use starcoin_statedb::{ChainStateDB, ChainStateReader};
 use starcoin_storage::{
     db_storage::DBStorage, storage::StorageInstance, BlockStore, Storage, StorageVersion,
 };
-use std::{
-    convert::TryInto,
-    fmt::Debug,
-    io::Write,
-    path::{Path, PathBuf},
-    sync::Arc,
-};
+use std::{fmt::Debug, io::Write, path::Path, sync::Arc};
 
 /// Export resources and code from storage for a specific block
 pub fn export(db: &str, output: &Path, block_id: HashValue) -> anyhow::Result<()> {
@@ -85,24 +78,6 @@ pub fn export_from_statedb<W: Write>(
     Ok(())
 }
 
-#[derive(Debug, Clone, Parser)]
-#[clap(
-    name = "resource-code-exporter",
-    about = "onchain resource and code exporter"
-)]
-pub struct ExporterOptions {
-    #[clap(long, short = 'o', parse(from_os_str))]
-    /// output file, like accounts.csv
-    pub output: PathBuf,
-    #[clap(long, short = 'i', parse(from_os_str))]
-    /// starcoin node db path. like ~/.starcoin/barnard/starcoindb/db/starcoindb
-    pub db_path: PathBuf,
-
-    #[clap(long)]
-    /// block id which snapshot at.
-    pub block_id: HashValue,
-}
-
 #[cfg(test)]
 mod test {
     use super::*;

cmd/resource-code-exporter/src/import.rs

@@ -1,11 +1,29 @@
 use starcoin_crypto::HashValue;
 use starcoin_statedb::{ChainStateDB, ChainStateReader, ChainStateWriter};
 use starcoin_storage::{db_storage::DBStorage, storage::StorageInstance, Storage, StorageVersion};
-use starcoin_types::account_address::AccountAddress;
-use starcoin_types::state_set::{AccountStateSet, ChainStateSet};
-use std::path::Path;
+use starcoin_types::{
+    account_address::AccountAddress,
+    state_set::{AccountStateSet, ChainStateSet},
+};
+use std::path::{Path, PathBuf};
 use std::sync::Arc;
 
+pub fn import_from_db_path(db_path: &PathBuf, csv_path: &PathBuf) -> anyhow::Result<()> {
+    let db_storage = DBStorage::open_with_cfs(
+        &db_path,
+        StorageVersion::current_version()
+            .get_column_family_names()
+            .to_vec(),
+        false,
+        Default::default(),
+        None,
+    )?;
+    let storage = Storage::new(StorageInstance::new_db_instance(db_storage))?;
+    let storage = Arc::new(storage);
+    let statedb = ChainStateDB::new(storage.clone(), None);
+    import(&statedb, csv_path)
+}
+
 /// Import resources and code from CSV file to a new statedb
 pub fn import(statedb: &ChainStateDB, csv_path: &Path) -> anyhow::Result<()> {
     // Read CSV file
@@ -50,7 +68,9 @@ pub fn import(statedb: &ChainStateDB, csv_path: &Path) -> anyhow::Result<()> {
 mod test {
     use super::*;
     use crate::export::export_from_statedb;
+    use starcoin_storage::db_storage::DBStorage;
     use std::fs::create_dir_all;
+    use std::sync::Arc;
     use tempfile::TempDir;
     use test_helper::executor::prepare_genesis;
 

cmd/resource-code-exporter/src/main.rs

@@ -4,17 +4,81 @@
 mod export;
 mod import;
 
-use crate::export::ExporterOptions;
-use clap::Parser;
+use clap::{Parser, Subcommand};
+use std::path::PathBuf;
+use starcoin_storage::{db_storage::DBStorage, storage::StorageInstance, Storage, StorageVersion};
+use starcoin_statedb::ChainStateDB;
+use std::sync::Arc;
+
+#[derive(Parser)]
+#[clap(name = "resource-code-exporter", about = "Export and import state data")]
+struct Cli {
+    #[clap(subcommand)]
+    command: Commands,
+}
+
+#[derive(Subcommand)]
+enum Commands {
+    /// Export state data to CSV file
+    Export {
+        #[clap(long, short = 'o', parse(from_os_str))]
+        /// Output file path, e.g. accounts.csv
+        output: PathBuf,
+        
+        #[clap(long, short = 'i', parse(from_os_str))]
+        /// Starcoin node db path, e.g. ~/.starcoin/barnard/starcoindb/db/starcoindb
+        db_path: PathBuf,
+
+        #[clap(long)]
+        /// Block id to export state at
+        block_id: starcoin_crypto::HashValue,
+    },
+    /// Import state data from CSV file
+    Import {
+        #[clap(long, short = 'i', parse(from_os_str))]
+        /// Input CSV file path
+        input: PathBuf,
+        
+        #[clap(long, short = 'o', parse(from_os_str))]
+        /// Output database path
+        db_path: PathBuf,
+    },
+}
 
 fn main() -> anyhow::Result<()> {
-    let option: ExporterOptions = ExporterOptions::parse();
-    let output = option.output.as_path();
-    let block_id = option.block_id;
-    export::export(
-        option.db_path.display().to_string().as_str(),
-        output,
-        block_id,
-    )?;
+    let cli = Cli::parse();
+
+    match cli.command {
+        Commands::Export {
+            output,
+            db_path,
+            block_id,
+        } => {
+            export::export(
+                db_path.display().to_string().as_str(),
+                &output,
+                block_id,
+            )?;
+        }
+        Commands::Import { input, db_path } => {
+            // Create new statedb for import
+            let db_storage = DBStorage::open_with_cfs(
+                &db_path,
+                StorageVersion::current_version()
+                    .get_column_family_names()
+                    .to_vec(),
+                false,
+                Default::default(),
+                None,
+            )?;
+            let storage = Storage::new(StorageInstance::new_db_instance(db_storage))?;
+            let storage = Arc::new(storage);
+            let statedb = ChainStateDB::new(storage.clone(), None);
+            
+            // Import data
+            import::import(&statedb, &input)?;
+        }
+    }
+
     Ok(())
 }