Merge pull request hyperledger-indy#659 from SergeyPalamarchuk/get_validator_info

Get validator info

Author: Vyacheslav

ci/indy-pool.dockerfile

@@ -19,16 +19,16 @@ RUN pip3 install -U \
 	setuptools
 
 RUN apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 68DB5E88
-ARG indy_stream=rc
+ARG indy_stream=master
 RUN echo "deb https://repo.sovrin.org/deb xenial $indy_stream" >> /etc/apt/sources.list
 
 RUN useradd -ms /bin/bash -u $uid indy
 
-ARG indy_plenum_ver=1.2.38
-ARG indy_anoncreds_ver=1.0.11
-ARG indy_node_ver=1.3.56
-ARG python3_indy_crypto_ver=0.2.0
-ARG indy_crypto_ver=0.1.6
+ARG indy_plenum_ver=1.2.369
+ARG indy_anoncreds_ver=1.0.32
+ARG indy_node_ver=1.3.425
+ARG python3_indy_crypto_ver=0.4.1
+ARG indy_crypto_ver=0.4.0
 
 RUN apt-get update -y && apt-get install -y \
         indy-plenum=${indy_plenum_ver} \

cli/src/commands/ledger.rs

@@ -326,6 +326,47 @@ pub mod schema_command {
     }
 }
 
+pub mod get_validator_info_command {
+    use super::*;
+
+    command!(CommandMetadata::build("get-validator-info", "Get validator info from all nodes.")
+                .add_example(r#"ledger get-validator-info"#)
+                .finalize()
+    );
+
+    fn execute(ctx: &CommandContext, params: &CommandParams) -> Result<(), ()> {
+        trace!("execute >> ctx {:?} params {:?}", ctx, params);
+
+        let submitter_did = ensure_active_did(&ctx)?;
+        let pool_handle = ensure_connected_pool_handle(&ctx)?;
+        let wallet_handle = ensure_opened_wallet_handle(&ctx)?;
+
+        let response = Ledger::build_get_validator_info_request(&submitter_did)
+            .and_then(|request| Ledger::sign_and_submit_request(pool_handle, wallet_handle, &submitter_did, &request))
+            .map_err(|err| handle_transaction_error(err, None, None, None))?;
+
+        let responses = match serde_json::from_str::<HashMap<String, String>>(&response) {
+            Ok(responses) => responses,
+            Err(err) => {
+                let response = serde_json::from_str::<Response<serde_json::Value>>(&response)
+                    .map_err(|err| println_err!("Invalid data has been received: {:?}", err))?;
+                return handle_transaction_response(response).map(|result| println_succ!("{}", result));
+            }
+        };
+
+        for (node, response) in responses {
+            let response = serde_json::from_str::<Response<serde_json::Value>>(&response)
+                .map_err(|err| println_err!("Invalid data has been received: {:?}", err))?;
+            println_succ!("Get validator info response for node {}:", node);
+            let _res = handle_transaction_response(response).map(|result| println!("{}", result));
+        }
+        let res = Ok(());
+
+        trace!("execute << {:?}", res);
+        res
+    }
+}
+
 pub mod get_schema_command {
     use super::*;
 
@@ -1950,6 +1991,30 @@ pub mod tests {
         }
     }
 
+    mod get_validator_info {
+        use super::*;
+
+        #[test]
+        pub fn get_validator_info_works() {
+            TestUtils::cleanup_storage();
+            let ctx = CommandContext::new();
+
+            create_and_open_wallet(&ctx);
+            create_and_connect_pool(&ctx);
+
+            new_did(&ctx, SEED_TRUSTEE);
+            use_did(&ctx, DID_TRUSTEE);
+            {
+                let cmd = get_validator_info_command::new();
+                let mut params = CommandParams::new();
+                cmd.execute(&ctx, &params).unwrap();
+            }
+            close_and_delete_wallet(&ctx);
+            disconnect_and_delete_pool(&ctx);
+            TestUtils::cleanup_storage();
+        }
+    }
+
     mod get_schema {
         use super::*;
 

cli/src/libindy/ledger.rs

@@ -191,6 +191,20 @@ impl Ledger {
         super::results::result_to_string(err, receiver)
     }
 
+    pub fn build_get_validator_info_request(submitter_did: &str) -> Result<String, ErrorCode> {
+        let (receiver, command_handle, cb) = super::callbacks::_closure_to_cb_ec_string();
+
+        let submitter_did = CString::new(submitter_did).unwrap();
+
+        let err = unsafe {
+            indy_build_get_validator_info_request(command_handle,
+                                         submitter_did.as_ptr(),
+                                         cb)
+        };
+
+        super::results::result_to_string(err, receiver)
+    }
+
     pub fn build_get_cred_def_request(submitter_did: &str, id: &str) -> Result<String, ErrorCode> {
         let (receiver, command_handle, cb) = super::callbacks::_closure_to_cb_ec_string();
 
@@ -360,6 +374,11 @@ extern {
                                      id: *const c_char,
                                      cb: Option<extern fn(xcommand_handle: i32, err: ErrorCode, request_json: *const c_char)>) -> ErrorCode;
 
+    #[no_mangle]
+    fn indy_build_get_validator_info_request(command_handle: i32,
+                                            submitter_did: *const c_char,
+                                            cb: Option<extern fn(xcommand_handle: i32, err: ErrorCode, request_json: *const c_char)>) -> ErrorCode;
+
     #[no_mangle]
     fn indy_build_cred_def_request(command_handle: i32,
                                    submitter_did: *const c_char,

cli/src/main.rs

@@ -95,6 +95,7 @@ fn build_executor() -> CommandExecutor {
         .add_command(ledger::get_attrib_command::new())
         .add_command(ledger::schema_command::new())
         .add_command(ledger::get_schema_command::new())
+        .add_command(ledger::get_validator_info_command::new())
         .add_command(ledger::cred_def_command::new())
         .add_command(ledger::get_cred_def_command::new())
         .add_command(ledger::node_command::new())

libindy/include/indy_ledger.h

@@ -476,6 +476,27 @@ extern "C" {
                                                                      const char*   request_json)
                                                );
 
+        /// Builds a GET_VALIDATOR_INFO request.
+        ///
+        /// #Params
+        /// command_handle: command handle to map callback to caller context.
+        /// submitter_did: Id of Identity stored in secured Wallet.
+        /// cb: Callback that takes command result as parameter.
+        ///
+        /// #Returns
+        /// Request result as json.
+        ///
+        /// #Errors
+        /// Common*
+
+        extern indy_error_t indy_build_get_validator_info_request(indy_handle_t command_handle,
+                                                       const char *  submitter_did,
+                                                       void           (*cb)(indy_handle_t xcommand_handle,
+                                                                            indy_error_t  err,
+                                                                            const char*   request_json)
+                                                       );
+
+
     /// Builds a GET_TXN request. Request to get any transaction by its seq_no.
     ///
     /// #Params

libindy/src/api/ledger.rs

@@ -889,6 +889,39 @@ pub extern fn indy_build_node_request(command_handle: i32,
     res
 }
 
+/// Builds a GET_VALIDATOR_INFO request.
+///
+/// #Params
+/// command_handle: command handle to map callback to caller context.
+/// submitter_did: Id of Identity stored in secured Wallet.
+/// cb: Callback that takes command result as parameter.
+///
+/// #Returns
+/// Request result as json.
+///
+/// #Errors
+/// Common*
+#[no_mangle]
+pub extern fn indy_build_get_validator_info_request(command_handle: i32,
+                                         submitter_did: *const c_char,
+                                         cb: Option<extern fn(xcommand_handle: i32, err: ErrorCode,
+                                                              request_json: *const c_char)>) -> ErrorCode {
+    check_useful_c_str!(submitter_did, ErrorCode::CommonInvalidParam2);
+    check_useful_c_callback!(cb, ErrorCode::CommonInvalidParam4);
+
+    let result = CommandExecutor::instance()
+        .send(Command::Ledger(LedgerCommand::BuildGetValidatorInfoRequest(
+            submitter_did,
+            Box::new(move |result| {
+                let (err, request_json) = result_to_err_code_1!(result, String::new());
+                let request_json = CStringUtils::string_to_cstring(request_json);
+                cb(command_handle, err, request_json.as_ptr())
+            })
+        )));
+
+    result_to_err_code!(result)
+}
+
 /// Builds a GET_TXN request. Request to get any transaction by its seq_no.
 ///
 /// #Params

libindy/src/commands/ledger.rs

@@ -108,6 +108,9 @@ pub enum LedgerCommand {
         String, // target_did
         String, // data
         Box<Fn(Result<String, IndyError>) + Send>),
+    BuildGetValidatorInfoRequest(
+        String, // submitter did
+        Box<Fn(Result<String, IndyError>) + Send>),
     BuildGetTxnRequest(
         String, // submitter did
         i32, // data
@@ -274,6 +277,10 @@ impl LedgerCommandExecutor {
                 info!(target: "ledger_command_executor", "BuildNodeRequest command received");
                 cb(self.build_node_request(&submitter_did, &target_did, &data));
             }
+            LedgerCommand::BuildGetValidatorInfoRequest(submitter_did, cb) => {
+                info!(target: "ledger_command_executor", "BuildGetValidatorInfoRequest command received");
+                cb(self.build_get_validator_info_request(&submitter_did));
+            }
             LedgerCommand::BuildGetTxnRequest(submitter_did, data, cb) => {
                 info!(target: "ledger_command_executor", "BuildGetTxnRequest command received");
                 cb(self.build_get_txn_request(&submitter_did, data));
@@ -640,6 +647,19 @@ impl LedgerCommandExecutor {
         Ok(res)
     }
 
+    fn build_get_validator_info_request(&self,
+                             submitter_did: &str) -> Result<String, IndyError> {
+        info!("build_get_validator_info_request >>> submitter_did: {:?}", submitter_did);
+
+        self.crypto_service.validate_did(submitter_did)?;
+
+        let res = self.ledger_service.build_get_validator_info_request(submitter_did)?;
+
+        info!("build_get_validator_info_request <<< res: {:?}", res);
+
+        Ok(res)
+    }
+
     fn build_get_txn_request(&self,
                              submitter_did: &str,
                              data: i32) -> Result<String, IndyError> {

libindy/src/services/ledger/constants.rs

@@ -5,6 +5,7 @@ pub const SCHEMA: &'static str = "101";
 pub const CRED_DEF: &'static str = "102";
 pub const GET_ATTR: &'static str = "104";
 pub const GET_NYM: &'static str = "105";
+pub const GET_VALIDATOR_INFO: &'static str = "119";
 pub const GET_TXN: &'static str = "3";
 pub const GET_SCHEMA: &'static str = "107";
 pub const GET_CRED_DEF: &'static str = "108";

libindy/src/services/ledger/mod.rs

@@ -239,6 +239,12 @@ impl LedgerService {
         Ok(request)
     }
 
+    pub fn build_get_validator_info_request(&self, identifier: &str) -> Result<String, CommonError> {
+        let operation = GetValidatorInfoOperation::new();
+        LedgerService::build_request(identifier, operation, "GET_VALIDATOR_INFO")
+            .map_err(|err| CommonError::InvalidState(format!("Invalid get validator info request json: {:?}", err)))
+    }
+
     pub fn build_get_txn_request(&self, identifier: &str, data: i32) -> Result<String, CommonError> {
         info!("build_get_txn_request >>> identifier: {:?}, data {:?}", identifier, data);
 

libindy/src/services/ledger/types.rs

@@ -303,6 +303,22 @@ impl GetDdoOperation {
 
 impl JsonEncodable for GetDdoOperation {}
 
+#[derive(Serialize, PartialEq, Debug)]
+pub struct GetValidatorInfoOperation {
+    #[serde(rename = "type")]
+    pub _type: String,
+}
+
+impl GetValidatorInfoOperation {
+    pub fn new() -> GetValidatorInfoOperation {
+        GetValidatorInfoOperation {
+            _type: GET_VALIDATOR_INFO.to_string(),
+        }
+    }
+}
+
+impl JsonEncodable for GetValidatorInfoOperation {}
+
 #[derive(Serialize, PartialEq, Debug)]
 pub struct GetTxnOperation {
     #[serde(rename = "type")]