verify-chain node client arg (#3678)

* 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
2022-01-07 14:45:48 +01:00
parent c92d2e9fba
commit a3eebbc0ab
7 changed files with 125 additions and 29 deletions
@@ -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))
 }
@@ -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())
 	}
 }
@@ -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.
@@ -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()
 				);
 				}*/
-			}
+		}
 	};
 }