rename variables

Signed-off-by: Andrew Whitehead <[email protected]>

Author: andrewwhitehead

indy-vdr-proxy/src/main.rs

@@ -313,7 +313,7 @@ async fn refresh_pool(
         tokio::time::sleep(Duration::from_secs((delay_mins * 60 / n_pools) as u64)).await
     }
 
-    let (txns, _timing) = perform_refresh(pool).await?;
+    let (txns, _meta) = perform_refresh(pool).await?;
 
     let cloned_state = state.clone();
     let pool_states = &cloned_state.borrow().pool_states;

libindy_vdr/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "indy-vdr"
-version = "0.4.0"
+version = "0.4.1"
 authors = [
     "Hyperledger Indy Contributors <[email protected]>",
 ]

libindy_vdr/src/ffi/pool.rs

@@ -107,7 +107,7 @@ pub extern "C" fn indy_vdr_pool_refresh(
         pool.refresh(Box::new(
             move |result| {
                 let errcode = match result {
-                    Ok((old_txns, new_txns, _timing)) => {
+                    Ok((old_txns, new_txns, _meta)) => {
                         if let Some(new_txns) = new_txns {
                             // We must spawn a new thread here because this callback
                             // is being run in the PoolRunner's thread, and if we drop
@@ -230,7 +230,7 @@ fn handle_request_result(
     result: VdrResult<(RequestResult<String>, RequestResultMeta)>,
 ) -> (ErrorCode, String) {
     match result {
-        Ok((reply, _timing)) => match reply {
+        Ok((reply, _meta)) => match reply {
             RequestResult::Reply(body) => (ErrorCode::Success, body),
             RequestResult::Failed(err) => {
                 let code = ErrorCode::from(err.kind());

libindy_vdr/src/lib.rs

@@ -32,7 +32,7 @@
 //! // Create a new GET_TXN request and dispatch it
 //! let ledger_type = 1;  // 1 identifies the Domain ledger, see pool::LedgerType
 //! let seq_no = 1;       // Transaction sequence number
-//! let (result, _timing) = block_on(perform_get_txn(&pool, ledger_type, seq_no)).unwrap();
+//! let (result, _meta) = block_on(perform_get_txn(&pool, ledger_type, seq_no)).unwrap();
 
 #![cfg_attr(feature = "fatal_warnings", deny(warnings))]
 #![recursion_limit = "1024"] // for select! macro usage

libindy_vdr/src/pool/helpers.rs

@@ -156,9 +156,9 @@ pub async fn perform_ledger_request<T: Pool>(
             node_aliases,
             timeout,
         } => {
-            let (result, timing) =
+            let (result, meta) =
                 handle_full_request(&mut request, node_aliases.clone(), *timeout).await?;
-            return Ok((result.map_result(format_full_reply)?, timing));
+            return Ok((result.map_result(format_full_reply)?, meta));
         }
         RequestMethod::BuiltinStateProof {
             sp_key,

libindy_vdr/src/pool/runner.rs

@@ -213,8 +213,8 @@ impl PoolThread {
 async fn _perform_refresh(pool: &LocalPool, callback: Callback<RefreshResponse>) {
     let result = {
         match perform_refresh(pool).await {
-            Ok((new_txns, timing)) => match pool.get_json_transactions() {
-                Ok(old_txns) => Ok((old_txns, new_txns, timing)),
+            Ok((new_txns, meta)) => match pool.get_json_transactions() {
+                Ok(old_txns) => Ok((old_txns, new_txns, meta)),
                 Err(err) => Err(err),
             },
             Err(err) => Err(err),

libindy_vdr/src/resolver/pool.rs

@@ -162,7 +162,7 @@ type SendReqResponse = VdrResult<(RequestResult<String>, RequestResultMeta)>;
 
 pub fn handle_resolution_result(result: SendReqResponse, did_url: String) -> VdrResult<String> {
     let did = DidUrl::parse(did_url.as_str())?;
-    let (req_result, _timing_result) = result?;
+    let (req_result, _meta) = result?;
 
     let ledger_data = match req_result {
         RequestResult::Reply(reply_data) => Ok(reply_data),

libindy_vdr/src/resolver/utils.rs

@@ -252,7 +252,7 @@ pub fn parse_or_now(datetime: Option<&String>) -> VdrResult<i64> {
 }
 
 pub async fn handle_request<T: Pool>(pool: &T, request: &PreparedRequest) -> VdrResult<String> {
-    let (result, _timing) = request_transaction(pool, request).await?;
+    let (result, _meta) = request_transaction(pool, request).await?;
     match result {
         RequestResult::Reply(data) => Ok(data),
         RequestResult::Failed(error) => Err(error),

libindy_vdr/tests/utils/pool.rs

@@ -60,7 +60,7 @@ impl TestPool {
 
     pub fn send_request(&self, prepared_request: &PreparedRequest) -> Result<String, String> {
         block_on(async {
-            let (request_result, _timing) = perform_ledger_request(&self.pool, prepared_request)
+            let (request_result, _meta) = perform_ledger_request(&self.pool, prepared_request)
                 .await
                 .unwrap();
 
@@ -78,7 +78,7 @@ impl TestPool {
         timeout: Option<i64>,
     ) -> VdrResult<NodeReplies<String>> {
         block_on(async {
-            let (request_result, _timing) = perform_ledger_action(
+            let (request_result, _meta) = perform_ledger_action(
                 &self.pool,
                 prepared_request.req_id.clone(),
                 prepared_request.req_json.to_string(),