Core/grin
0
0
Fork 0
mirror of https://github.com/mimblewimble/grin.git synced 2025-01-20 19:11:08 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions

verify-chain node client arg (#3678)

Browse source 
* add parameter fast_validation to the api

* arg `verify-chain` on node client

* arg verify chain + read_timeout parameter

* change timeout to 2hours

* update with tromp review

* 2nd comment from tromp
This commit is contained in:
deevope 2022-01-07 14:45:48 +01:00 committed by GitHub
parent c92d2e9fba
commit a3eebbc0ab
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
7 changed files with 125 additions and 29 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

80
api/src/client.rs
View file

@ -25,6 +25,33 @@ use serde::{Deserialize, Serialize};
use std::time::Duration;
use tokio::runtime::Builder;
// Client Request Timeout
pub struct TimeOut {
pub connect: Duration,
pub read: Duration,
pub write: Duration,
}
impl TimeOut {
pub fn new(connect: u64, read: u64, write: u64) -> Self {
Self {
connect: Duration::from_secs(connect),
read: Duration::from_secs(read),
write: Duration::from_secs(write),
}
}
}
impl Default for TimeOut {
fn default() -> TimeOut {
TimeOut {
connect: Duration::from_secs(20),
read: Duration::from_secs(20),
write: Duration::from_secs(20),
}
}
}
/// Helper function to easily issue a HTTP GET request against a given URL that
/// returns a JSON object. Handles request building, JSON deserialization and
/// response code checking.
@ -35,7 +62,10 @@ pub fn get<T>(url: &str, api_secret: Option<String>) -> Result<T, Error>
where
for<'de> T: Deserialize<'de>,
{
handle_request(build_request(url, "GET", api_secret, None)?)
handle_request(
build_request(url, "GET", api_secret, None)?,
TimeOut::default(),
)
}
/// Helper function to easily issue an async HTTP GET request against a given
@ -52,7 +82,10 @@ where
/// on a given URL that returns nothing. Handles request
/// building and response code checking.
pub fn get_no_ret(url: &str, api_secret: Option<String>) -> Result<(), Error> {
send_request(build_request(url, "GET", api_secret, None)?)?;
send_request(
build_request(url, "GET", api_secret, None)?,
TimeOut::default(),
)?;
Ok(())
}
@ -60,13 +93,18 @@ pub fn get_no_ret(url: &str, api_secret: Option<String>) -> Result<(), Error> {
/// object as body on a given URL that returns a JSON object. Handles request
/// building, JSON serialization and deserialization, and response code
/// checking.
pub fn post<IN, OUT>(url: &str, api_secret: Option<String>, input: &IN) -> Result<OUT, Error>
pub fn post<IN, OUT>(
url: &str,
api_secret: Option<String>,
input: &IN,
timeout: TimeOut,
) -> Result<OUT, Error>
where
IN: Serialize,
for<'de> OUT: Deserialize<'de>,
{
let req = create_post_request(url, api_secret, input)?;
handle_request(req)
handle_request(req, timeout)
}
/// Helper function to easily issue an async HTTP POST request with the
@ -94,7 +132,10 @@ pub fn post_no_ret<IN>(url: &str, api_secret: Option<String>, input: &IN) -> Res
where
IN: Serialize,
{
send_request(create_post_request(url, api_secret, input)?)?;
send_request(
create_post_request(url, api_secret, input)?,
TimeOut::default(),
)?;
Ok(())
}
@ -110,7 +151,11 @@ pub async fn post_no_ret_async<IN>(
where
IN: Serialize,
{
send_request_async(create_post_request(url, api_secret, input)?).await?;
send_request_async(
create_post_request(url, api_secret, input)?,
TimeOut::default(),
)
.await?;
Ok(())
}
@ -155,11 +200,11 @@ where
build_request(url, "POST", api_secret, Some(json))
}
fn handle_request<T>(req: Request<Body>) -> Result<T, Error>
fn handle_request<T>(req: Request<Body>, timeout: TimeOut) -> Result<T, Error>
where
for<'de> T: Deserialize<'de>,
{
let data = send_request(req)?;
let data = send_request(req, timeout)?;
serde_json::from_str(&data).map_err(|e| {
e.context(ErrorKind::ResponseError("Cannot parse response".to_owned()))
.into()
@ -170,18 +215,23 @@ async fn handle_request_async<T>(req: Request<Body>) -> Result<T, Error>
where
for<'de> T: Deserialize<'de> + Send + 'static,
{
let data = send_request_async(req).await?;
let data = send_request_async(req, TimeOut::default()).await?;
let ser = serde_json::from_str(&data)
.map_err(|e| e.context(ErrorKind::ResponseError("Cannot parse response".to_owned())))?;
Ok(ser)
}
async fn send_request_async(req: Request<Body>) -> Result<String, Error> {
async fn send_request_async(req: Request<Body>, timeout: TimeOut) -> Result<String, Error> {
let https = hyper_rustls::HttpsConnector::new();
let (connect, read, write) = (
Some(timeout.connect),
Some(timeout.read),
Some(timeout.write),
);
let mut connector = TimeoutConnector::new(https);
connector.set_connect_timeout(Some(Duration::from_secs(20)));
connector.set_read_timeout(Some(Duration::from_secs(20)));
connector.set_write_timeout(Some(Duration::from_secs(20)));
connector.set_connect_timeout(connect);
connector.set_read_timeout(read);
connector.set_write_timeout(write);
let client = Client::builder().build::<_, Body>(connector);
let resp = client
@ -205,11 +255,11 @@ async fn send_request_async(req: Request<Body>) -> Result<String, Error> {
Ok(String::from_utf8_lossy(&raw).to_string())
}
pub fn send_request(req: Request<Body>) -> Result<String, Error> {
pub fn send_request(req: Request<Body>, timeout: TimeOut) -> Result<String, Error> {
let mut rt = Builder::new()
.basic_scheduler()
.enable_all()
.build()
.map_err(|e| ErrorKind::RequestError(format!("{}", e)))?;
rt.block_on(send_request_async(req))
rt.block_on(send_request_async(req, timeout))
}

4
api/src/handlers/chain_api.rs
View file

@ -53,9 +53,9 @@ pub struct ChainValidationHandler {
}
impl ChainValidationHandler {
pub fn validate_chain(&self) -> Result<(), Error> {
pub fn validate_chain(&self, fast_validation: bool) -> Result<(), Error> {
w(&self.chain)?
.validate(true)
.validate(fast_validation)
.map_err(|_| ErrorKind::Internal("chain error".to_owned()).into())
}
}

7
api/src/owner.rs
View file

@ -80,17 +80,20 @@ impl Owner {
/// Trigger a validation of the chain state.
///
/// # Arguments
/// * `assume_valid_rangeproofs_kernels` - if false, will validate rangeproofs, kernel signatures and sum of kernel excesses. if true, will only validate the sum of kernel excesses should equal the sum of unspent outputs minus total supply.
///
/// # Returns
/// * Result Containing:
/// * `Ok(())` if the validation was done successfully
/// * or [`Error`](struct.Error.html) if an error is encountered.
///
pub fn validate_chain(&self) -> Result<(), Error> {
pub fn validate_chain(&self, assume_valid_rangeproofs_kernels: bool) -> Result<(), Error> {
let chain_validation_handler = ChainValidationHandler {
chain: self.chain.clone(),
};
chain_validation_handler.validate_chain()
chain_validation_handler.validate_chain(assume_valid_rangeproofs_kernels)
}
/// Trigger a compaction of the chain state to regain storage space.

12
api/src/owner_rpc.rs
View file

@ -83,7 +83,7 @@ pub trait OwnerRpc: Sync + Send {
{
"jsonrpc": "2.0",
"method": "validate_chain",
"params": [],
"params": ["false"],
"id": 1
}
# "#
@ -100,7 +100,7 @@ pub trait OwnerRpc: Sync + Send {
# );
```
*/
fn validate_chain(&self) -> Result<(), ErrorKind>;
fn validate_chain(&self, assume_valid_rangeproofs_kernels: bool) -> Result<(), ErrorKind>;
/**
Networked version of [Owner::compact_chain](struct.Owner.html#method.compact_chain).
@ -363,8 +363,8 @@ impl OwnerRpc for Owner {
Owner::get_status(self).map_err(|e| e.kind().clone())
}
fn validate_chain(&self) -> Result<(), ErrorKind> {
Owner::validate_chain(self).map_err(|e| e.kind().clone())
fn validate_chain(&self, assume_valid_rangeproofs_kernels: bool) -> Result<(), ErrorKind> {
Owner::validate_chain(self, assume_valid_rangeproofs_kernels).map_err(|e| e.kind().clone())
}
fn reset_chain_head(&self, hash: String) -> Result<(), ErrorKind> {
@ -403,7 +403,7 @@ macro_rules! doctest_helper_json_rpc_owner_assert_response {
// create temporary grin server, run jsonrpc request on node api, delete server, return
// json response.
{
{
/*use grin_servers::test_framework::framework::run_doctest;
use grin_util as util;
use serde_json;
@ -437,6 +437,6 @@ macro_rules! doctest_helper_json_rpc_owner_assert_response {
serde_json::to_string_pretty(&expected_response).unwrap()
);
}*/
}
}
};
}

3
servers/src/mining/mine_block.rs
View file

@ -262,7 +262,8 @@ fn create_coinbase(dest: &str, block_fees: &BlockFees) -> Result<CbData, Error>
trace!("Sending build_coinbase request: {}", req_body);
let req = api::client::create_post_request(url.as_str(), None, &req_body)?;
let res: String = api::client::send_request(req).map_err(|e| {
let timeout = api::client::TimeOut::default();
let res: String = api::client::send_request(req, timeout).map_err(|e| {
let report = format!(
"Failed to get coinbase from {}. Is the wallet listening? {}",
dest, e

38
src/bin/cmd/client.rs
View file

@ -45,10 +45,19 @@ impl HTTPNodeClient {
method: &str,
params: &serde_json::Value,
) -> Result<D, Error> {
let timeout = match method {
// 6 hours read timeout
"validate_chain" => client::TimeOut::new(20, 21600, 20),
_ => client::TimeOut::default(),
};
let url = format!("http://{}{}", self.node_url, ENDPOINT);
let req = build_request(method, params);
let res =
client::post::<Request, Response>(url.as_str(), self.node_api_secret.clone(), &req);
let res = client::post::<Request, Response>(
url.as_str(),
self.node_api_secret.clone(),
&req,
timeout,
);
match res {
Err(e) => {
@ -149,6 +158,27 @@ impl HTTPNodeClient {
e.reset().unwrap();
}
pub fn verify_chain(&self, assume_valid_rangeproofs_kernels: bool) {
let mut e = term::stdout().unwrap();
let params = json!([assume_valid_rangeproofs_kernels]);
writeln!(
e,
"Checking the state of the chain. This might take time..."
)
.unwrap();
match self.send_json_request::<()>("validate_chain", &params) {
Ok(_) => {
if assume_valid_rangeproofs_kernels {
writeln!(e, "Successfully validated the sum of kernel excesses! [fast_verification enabled]").unwrap()
} else {
writeln!(e, "Successfully validated the sum of kernel excesses, kernel signature and rangeproofs!").unwrap()
}
}
Err(err) => writeln!(e, "Failed to validate chain: {:?}", err).unwrap(),
}
e.reset().unwrap();
}
pub fn ban_peer(&self, peer_addr: &SocketAddr) {
let mut e = term::stdout().unwrap();
let params = json!([peer_addr]);
@ -191,6 +221,10 @@ pub fn client_command(client_args: &ArgMatches<'_>, global_config: GlobalConfig)
let hash = args.value_of("hash").unwrap();
node_client.invalidate_header(hash.to_string());
}
("verify-chain", Some(args)) => {
let assume_valid_rangeproofs_kernels = args.is_present("fast");
node_client.verify_chain(assume_valid_rangeproofs_kernels);
}
("ban", Some(peer_args)) => {
let peer = peer_args.value_of("peer").unwrap();

8
src/bin/grin.yml
View file

@ -78,6 +78,14 @@ subcommands:
- hash:
help: The header hash to reset to
required: true
- verify-chain:
about: Trigger a verication of the rangeproofs, kernel signatures and excesses.
args:
- fast:
help: if present, will skip verification of rangeproofs, kernel signatures and will only validate the sum of kernel excesses.
short: f
long: fast
takes_value: false
- invalidateheader:
about: Adds header hash to denylist
args: