add a node cmd to reset node startup info

cmd/starcoin/src/lib.rs

@@ -60,6 +60,7 @@ pub fn add_command(
                 .subcommand(node::InfoCommand)
                 .subcommand(node::PeersCommand)
                 .subcommand(node::MetricsCommand)
+                .subcommand(node::ResetCommand)
                 .subcommand(
                     Command::with_name("service")
                         .subcommand(node::service::ListCommand)

cmd/starcoin/src/node/mod.rs

@@ -6,9 +6,10 @@ mod metrics_cmd;
 mod peers_cmd;
 
 pub mod network;
+pub mod reset_cmd;
 pub mod service;
 pub mod sync;
-
 pub use info_cmd::*;
 pub use metrics_cmd::*;
 pub use peers_cmd::*;
+pub use reset_cmd::*;

cmd/starcoin/src/node/reset_cmd.rs

@@ -0,0 +1,34 @@
+// Copyright (c) The Starcoin Core Contributors
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::cli_state::CliState;
+use crate::StarcoinOpt;
+use anyhow::Result;
+use scmd::{CommandAction, ExecContext};
+use starcoin_crypto::HashValue;
+use structopt::StructOpt;
+
+#[derive(Debug, StructOpt)]
+#[structopt(name = "reset")]
+pub struct ResetOpt {
+    #[structopt(name = "block-hash")]
+    block_hash: HashValue,
+}
+
+pub struct ResetCommand;
+
+impl CommandAction for ResetCommand {
+    type State = CliState;
+    type GlobalOpt = StarcoinOpt;
+    type Opt = ResetOpt;
+    type ReturnItem = ();
+
+    fn run(
+        &self,
+        ctx: &ExecContext<Self::State, Self::GlobalOpt, Self::Opt>,
+    ) -> Result<Self::ReturnItem> {
+        let client = ctx.state().client();
+        client.reset_node(ctx.opt().block_hash)?;
+        Ok(())
+    }
+}

node/api/src/message.rs

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use anyhow::Result;
+use starcoin_crypto::HashValue;
 use starcoin_service_registry::{ServiceInfo, ServiceRequest, ServiceStatus};
 
 #[derive(Debug, Clone)]
@@ -13,6 +14,7 @@ pub enum NodeRequest {
     StopPacemaker,
     StartPacemaker,
     ShutdownSystem,
+    ResetNode(HashValue),
 }
 
 #[derive(Debug)]

node/api/src/node_service.rs

@@ -3,6 +3,7 @@
 
 use crate::message::{NodeRequest, NodeResponse};
 use anyhow::Result;
+use starcoin_crypto::HashValue;
 use starcoin_service_registry::{
     ActorService, ServiceHandler, ServiceInfo, ServiceRef, ServiceStatus,
 };
@@ -24,6 +25,7 @@ pub trait NodeAsyncService:
     async fn stop_pacemaker(&self) -> Result<()>;
 
     async fn shutdown_system(&self) -> Result<()>;
+    async fn reset_node(&self, block_hash: HashValue) -> Result<()>;
 }
 
 #[async_trait::async_trait]
@@ -91,4 +93,8 @@ where
         self.try_send(NodeRequest::ShutdownSystem)?;
         Ok(())
     }
+    async fn reset_node(&self, block_hash: HashValue) -> Result<()> {
+        self.try_send(NodeRequest::ResetNode(block_hash))?;
+        Ok(())
+    }
 }

node/src/node.rs

@@ -40,14 +40,15 @@ use starcoin_storage::cache_storage::CacheStorage;
 use starcoin_storage::db_storage::DBStorage;
 use starcoin_storage::errors::StorageInitError;
 use starcoin_storage::storage::StorageInstance;
-use starcoin_storage::Storage;
+use starcoin_storage::{BlockStore, Storage};
 use starcoin_stratum::service::{StratumService, StratumServiceFactory};
 use starcoin_stratum::stratum::{Stratum, StratumFactory};
 use starcoin_sync::announcement::AnnouncementService;
 use starcoin_sync::block_connector::BlockConnectorService;
 use starcoin_sync::sync::SyncService;
 use starcoin_sync::txn_sync::TxnSyncService;
 use starcoin_txpool::TxPoolActorService;
+use starcoin_types::startup_info::StartupInfo;
 use starcoin_types::system_events::SystemStarted;
 use std::sync::Arc;
 use std::time::Duration;
@@ -116,6 +117,14 @@ impl ServiceHandler<Self, NodeRequest> for NodeService {
                 self.registry
                     .start_service_sync(GenerateBlockEventPacemaker::service_name()),
             ),
+            NodeRequest::ResetNode(block_hash) => {
+                let storage = self
+                    .registry
+                    .get_shared_sync::<Arc<Storage>>()
+                    .expect("Storage must exist.");
+                info!("Prepare to reset node startup info to {}", block_hash);
+                NodeResponse::Result(storage.save_startup_info(StartupInfo { main: block_hash }))
+            }
         })
     }
 }

rpc/api/src/node_manager.rs

@@ -4,6 +4,7 @@
 pub use self::gen_client::Client as NodeManagerClient;
 use crate::FutureResult;
 use jsonrpc_derive::rpc;
+use starcoin_crypto::HashValue;
 use starcoin_service_registry::{ServiceInfo, ServiceStatus};
 
 #[rpc]
@@ -22,4 +23,6 @@ pub trait NodeManagerApi {
 
     #[rpc(name = "node_manager.shutdown_system")]
     fn shutdown_system(&self) -> FutureResult<()>;
+    #[rpc(name = "node_manager.reset_to_block")]
+    fn reset_to_block(&self, block_number: HashValue) -> FutureResult<()>;
 }

rpc/client/src/lib.rs

@@ -248,7 +248,10 @@ impl RpcClient {
         self.call_rpc_blocking(|inner| inner.node_manager_client.shutdown_system())
             .map_err(map_err)
     }
-
+    pub fn reset_node(&self, block_hash: HashValue) -> anyhow::Result<()> {
+        self.call_rpc_blocking(|inner| inner.node_manager_client.reset_to_block(block_hash))
+            .map_err(map_err)
+    }
     pub fn next_sequence_number_in_txpool(
         &self,
         address: AccountAddress,

rpc/server/src/module/node_manager_rpc.rs

@@ -4,6 +4,7 @@
 use crate::module::map_err;
 use futures::future::TryFutureExt;
 use futures::FutureExt;
+use starcoin_crypto::HashValue;
 use starcoin_node_api::node_service::NodeAsyncService;
 use starcoin_rpc_api::node_manager::NodeManagerApi;
 use starcoin_rpc_api::FutureResult;
@@ -74,4 +75,13 @@ where
         .map_err(map_err);
         Box::pin(fut.boxed())
     }
+    fn reset_to_block(&self, block_hash: HashValue) -> FutureResult<()> {
+        let service = self.service.clone();
+        let fut = async move {
+            service.reset_node(block_hash).await?;
+            Ok(())
+        }
+        .map_err(map_err);
+        Box::pin(fut.boxed())
+    }
 }