Merge branch 'master' into rc

cli/src/commands/ledger.rs

@@ -2042,6 +2042,89 @@ pub mod get_acceptance_mechanisms_command {
     }
 }
 
+pub mod ledgers_freeze_command {
+    use super::*;
+
+    command!(CommandMetadata::build("ledgers-freeze", r#"Freeze ledgers"#)
+                .add_required_param("ledgers_ids", "List of ledgers IDs for freezing.")
+                .add_example("ledger ledgers-freeze ledgers_ids=1,2,3")
+                .finalize()
+    );
+
+    fn execute(ctx: &CommandContext, params: &CommandParams) -> Result<(), ()> {
+        trace!("execute >> ctx {:?} params {:?}", ctx, params);
+        let ledgers_ids = get_number_tuple_array_param("ledgers_ids", params);
+        let submitter_did = ensure_active_did(&ctx)?;
+        let (wallet_handle, wallet_name) = ensure_opened_wallet(&ctx)?;
+
+        let request = Ledger::build_ledgers_freeze_request(&submitter_did, ledgers_ids?)
+            .map_err(|err| handle_indy_error(err, None, None, None))?;
+
+        let (_, response) = send_write_request!(&ctx, params, &request, wallet_handle, &wallet_name, &submitter_did);
+
+        let result = handle_transaction_response(response)?;
+
+        println!("result {:?}", result);
+
+        trace!("execute <<");
+        Ok(())
+    }
+}
+
+pub mod get_frozen_ledgers_command {
+    use super::*;
+
+    command!(CommandMetadata::build("get-frozen-ledgers", r#"Get a list of frozen ledgers"#)
+                .add_example("ledger get-frozen-ledgers")
+                .finalize()
+    );
+
+    fn execute(ctx: &CommandContext, params: &CommandParams) -> Result<(), ()> {
+        trace!("execute >> ctx {:?} params {:?}", ctx, params);
+
+        let submitter_did = ensure_active_did(&ctx)?;
+
+        let request = Ledger::build_get_frozen_ledgers_request(&submitter_did)
+            .map_err(|err| handle_indy_error(err, None, None, None))?;
+
+        let (_, response) = send_read_request!(&ctx, params, &request, Some(&submitter_did));
+        let handle_response = handle_transaction_response(response)?;
+
+        // Flattering ap into vector
+        let handle_response = handle_response.as_object()
+            .expect("top level object is not a map");
+
+        let mut result = Vec::new();
+        for (response_ledger_key, response_ledger_value) in handle_response {
+            let mut ledger_info = response_ledger_value.as_object()
+                .expect("inner object is not a map").clone();
+
+            let ledger_id = serde_json::to_value(&response_ledger_key)
+                .map_err(|_| println_err!("Invalid format of Outputs: Ledger ID is incorrect."))?;
+            ledger_info.insert("ledger_id".to_owned(), ledger_id);
+
+            result.push(serde_json::to_value(&ledger_info)
+                .map_err(|_| println_err!("Invalid format of Outputs: result is incorrect."))?);
+        }
+
+        print_frozen_ledgers(result)?;
+        trace!("execute <<");
+        Ok(())
+    }
+
+    fn print_frozen_ledgers(frozen_ledgers: Vec<serde_json::Value>) -> Result<(), ()> {
+        println_succ!("Frozen ledgers has been received.");
+        print_list_table(&frozen_ledgers,
+                         &[("ledger_id", "Ledger id"),
+                             ("ledger", "Ledger root hash"),
+                             ("state", "State root hash"),
+                             ("seq_no", "Last sequance number")],
+                         "No frozen ledgers found.");
+
+        Ok(())
+    }
+}
+
 pub fn set_author_agreement(ctx: &CommandContext, request: &mut String) -> Result<(), ()> {
     if let Some((text, version, acc_mech_type, time_of_acceptance)) = get_transaction_author_info(&ctx) {
         if acc_mech_type.is_empty() {
@@ -2251,6 +2334,8 @@ fn get_txn_title(role: &serde_json::Value) -> serde_json::Value {
         Some("5") => "TXN_AUTHR_AGRMT_AML",
         Some("6") => "GET_TXN_AUTHR_AGRMT",
         Some("7") => "GET_TXN_AUTHR_AGRMT_AML",
+        Some("9") => "LEDGERS_FREEZE",
+        Some("10") => "GET_FROZEN_LEDGERS",
         Some("100") => "ATTRIB",
         Some("101") => "SCHEMA",
         Some("104") => "GET_ATTR",
@@ -5079,6 +5164,37 @@ pub mod tests {
         }
     }
 
+    mod frozen_ledgers {
+        use super::*;
+
+        #[test]
+        pub fn ledgers_freeze() {
+            let ctx = setup();
+
+            {
+                let cmd = ledgers_freeze_command::new();
+                let mut params = CommandParams::new();
+                params.insert("ledgers_ids", "0,1,10,237".to_string());
+                cmd.execute(&ctx, &params).unwrap_err();
+            }
+
+            tear_down();
+        }
+
+        #[test]
+        pub fn get_frozen_ledgers() {
+            let ctx = setup();
+
+            {
+                let cmd = get_frozen_ledgers_command::new();
+                let params = CommandParams::new();
+                cmd.execute(&ctx, &params).unwrap_err();
+            }
+
+            tear_down();
+        }
+    }
+
     fn _path() -> (::std::path::PathBuf, String) {
         let mut path = crate::utils::environment::EnvironmentUtils::indy_home_path();
         path.push("transaction");

cli/src/commands/mod.rs

@@ -166,6 +166,30 @@ pub fn get_str_tuple_array_param<'a>(name: &'a str, params: &'a CommandParams) -
     }
 }
 
+pub fn get_number_tuple_array_param<'a>(name: &'a str, params: &'a CommandParams) -> Result<Vec<u64>, ()> {
+    match params.get(name) {
+        Some(v) if !v.is_empty() => {
+            let tuples: Vec<&str> = v.split(",").collect();
+            if tuples.is_empty() {
+                println_err!("Parameter \"{}\" has invalid format", name);
+                Err(())
+            } else {
+                let mut result: Vec<u64> = Vec::new();
+                for item in tuples {
+                    println!("{:?}",item);
+                    result.push(item.parse::<u64>().map_err(|err|
+                        println_err!("Can't parse number parameter \"{}\": value: \"{}\", err \"{}\"", name, item, err))?);
+                }
+                Ok(result)
+            }
+        }
+        _ => {
+            println_err!("No required \"{}\" parameter present", name);
+            Err(())
+        }
+    }
+}
+
 pub fn get_opt_str_tuple_array_param<'a>(name: &'a str, params: &'a CommandParams) -> Result<Option<Vec<String>>, ()> {
     match params.get(name) {
         Some(v) =>

cli/src/libindy/ledger.rs

@@ -147,4 +147,12 @@ impl Ledger {
                                    endorser_did: &str) -> Result<String, IndyError> {
         ledger::append_request_endorser(request_json, endorser_did).wait()
     }
+
+    pub fn build_ledgers_freeze_request(submitter_did: &str, ledgers_ids: Vec<u64>) -> Result<String, IndyError> {
+        ledger::build_ledgers_freeze_request(submitter_did, ledgers_ids).wait()
+    }
+
+    pub fn build_get_frozen_ledgers_request(submitter_did: &str) -> Result<String, IndyError> {
+        ledger::build_get_frozen_ledgers_request(submitter_did).wait()
+    }
 }

cli/src/main.rs

@@ -188,6 +188,8 @@ fn build_executor() -> CommandExecutor {
         .add_command(ledger::get_acceptance_mechanisms_command::new())
         .add_command(ledger::endorse_transaction_command::new())
         .add_command(ledger::taa_disable_all_command::new())
+        .add_command(ledger::ledgers_freeze_command::new())
+        .add_command(ledger::get_frozen_ledgers_command::new())
         .finalize_group()
         .add_group(payment_address::group::new())
         .add_command(payment_address::new_command::new())

experimental/plugins/postgres_storage/Cargo.toml

@@ -68,6 +68,7 @@ log-panics = "2.0.0"
 postgres = "0.15.2"
 r2d2 = "0.8.2"
 r2d2_postgres = "0.14.0"
+percent-encoding = "2.1.0"
 
 [dependencies.uuid]
 version = "0.5.0"

experimental/plugins/postgres_storage/src/postgres_storage.rs

@@ -2,6 +2,7 @@ extern crate owning_ref;
 extern crate sodiumoxide;
 extern crate r2d2;
 extern crate r2d2_postgres;
+extern crate percent_encoding;
 
 use ::std::sync::RwLock;
 
@@ -13,6 +14,8 @@ use self::owning_ref::OwningHandle;
 use std::rc::Rc;
 use std::time::Duration;
 
+use self::percent_encoding::{utf8_percent_encode, NON_ALPHANUMERIC};
+
 use errors::wallet::WalletStorageError;
 use errors::common::CommonError;
 use wql::language;
@@ -193,7 +196,7 @@ const _CREATE_SCHEMA_MULTI: [&str; 14] = [
             ON UPDATE CASCADE
     )",
     "CREATE INDEX IF NOT EXISTS ix_tags_encrypted_name ON tags_encrypted(wallet_id, name)",
-    "CREATE INDEX IF NOT EXISTS ix_tags_encrypted_value ON tags_encrypted(wallet_id, value)",
+    "CREATE INDEX IF NOT EXISTS ix_tags_encrypted_value ON tags_encrypted(wallet_id, md5(value))",
     "CREATE INDEX IF NOT EXISTS ix_tags_encrypted_wallet_id_item_id ON tags_encrypted(wallet_id, item_id)",
     "CREATE TABLE IF NOT EXISTS tags_plaintext(
         wallet_id VARCHAR(64) NOT NULL,
@@ -1037,19 +1040,20 @@ impl PostgresStorageType {
         }
         url_base.push_str(":");
         match credentials.admin_password {
-            Some(ref password) => url_base.push_str(&password[..]),
+            Some(ref password) => url_base.push_str(&utf8_percent_encode(&password[..], &NON_ALPHANUMERIC).to_string()),
             None => ()
         }
         url_base.push_str("@");
         url_base.push_str(&config.url[..]);
+        url_base.push_str("/postgres");
         url_base
     }
 
     fn _base_postgres_url(config: &PostgresConfig, credentials: &PostgresCredentials) -> String {
         let mut url_base = "postgresql://".to_owned();
         url_base.push_str(&credentials.account[..]);
         url_base.push_str(":");
-        url_base.push_str(&credentials.password[..]);
+        url_base.push_str(&utf8_percent_encode(&credentials.password[..], &NON_ALPHANUMERIC).to_string());
         url_base.push_str("@");
         url_base.push_str(&config.url[..]);
         url_base

libindy/Cargo.toml

@@ -30,7 +30,7 @@ fatal_warnings = []
 env_logger = "0.7"
 etcommon-rlp = "0.2.4"
 failure = "0.1.7"
-hex = "0.3.2"
+hex = "0.4.0"
 libc = "0.2.66"
 log = "0.4.8"
 log-derive = "0.3.0"
@@ -41,8 +41,8 @@ rust-base58 = {version = "0.0.4", optional = true}
 serde = "1.0.99"
 serde_json = "1.0.40"
 serde_derive = "1.0.99"
-sha2 = "0.8"
-sha3 = "0.8"
+sha2 = "0.9"
+sha3 = "0.9"
 rmp-serde = "0.13.7"
 time = "0.1.42"
 threadpool = "1.7.1"
@@ -133,4 +133,4 @@ depends = "libindy (= 1.16.0)"
 assets = [
     ["include/*.h", "usr/include/indy/", "644"],
     ["target/release/libindy.a", "usr/lib/", "644"],
-]
+]

libindy/ci/centos.dockerfile

@@ -63,13 +63,13 @@ RUN cd /usr/src && \
 RUN yum install -y ncurses-devel
 
 RUN cd /tmp && \
-    wget https://github.com/zeromq/libzmq/releases/download/v4.2.2/zeromq-4.2.2.tar.gz && \
-    tar xfz zeromq-4.2.2.tar.gz && rm zeromq-4.2.2.tar.gz && \
-    cd /tmp/zeromq-4.2.2 && \
+    wget https://github.com/zeromq/libzmq/releases/download/v4.3.3/zeromq-4.3.3.tar.gz && \
+    tar xfz zeromq-4.3.3.tar.gz && rm zeromq-4.3.3.tar.gz && \
+    cd /tmp/zeromq-4.3.3 && \
     ./configure && \
     make && \
     make install && \
-    rm -rf /tmp/zeromq-4.2.2
+    rm -rf /tmp/zeromq-4.3.3
 
 RUN yum install fakeroot -y
 

libindy/include/indy_ledger.h

@@ -1256,6 +1256,57 @@ extern "C" {
                                                                                       const char*   request_json)
                                                                 );
 
+    /// Builds a LEDGERS_FREEZE request. Request to freeze list of ledgers.
+    ///
+    /// #Params
+    /// command_handle: command handle to map callback to caller context.
+    /// submitter_did: (Optional) DID of the read request sender (if not provided then default Libindy DID will be used).
+    /// ledgers_ids: list of ledgers IDs for freezing ledgers (json format).
+    /// cb: Callback that takes command result as parameter.
+    ///
+    /// #Returns
+    /// Request result as json.
+    ///
+    /// #Errors
+    /// Common*
+    extern indy_error_t indy_build_ledgers_freeze_request(indy_handle_t command_handle,
+                                                                 const char *  submitter_did,
+                                                                 const char *  ledgers_ids,
+
+                                                                 void           (*cb)(indy_handle_t command_handle_,
+                                                                                      indy_error_t  err,
+                                                                                      const char*   request_json)
+                                                                );
+
+    /// Builds a GET_FROZEN_LEDGERS request. Request to get list of frozen ledgers.
+    /// frozen ledgers are defined by LEDGERS_FREEZE request.
+    ///
+    /// #Params
+    /// command_handle: command handle to map callback to caller context.
+    /// submitter_did: (Optional) DID of the read request sender (if not provided then default Libindy DID will be used).
+    /// cb: Callback that takes command result as parameter.
+    ///
+    /// #Returns
+    /// Request result as json.
+    ///  {
+    ///     <ledger_id>: {
+    ///         "ledger": String - Ledger root hash,
+    ///         "state": String - State root hash,
+    ///         "seq_no": u64 - the latest transaction seqNo for particular Node,
+    ///     },
+    ///     ...
+    /// }
+    ///
+    /// #Errors
+    /// Common*
+    extern indy_error_t indy_build_get_frozen_ledgers_request(indy_handle_t command_handle,
+                                                                 const char *  submitter_did,
+
+                                                                 void           (*cb)(indy_handle_t command_handle_,
+                                                                                      indy_error_t  err,
+                                                                                      const char*   request_json)
+                                                                );
+
     /// Builds a GET_TXN_AUTHR_AGRMT_AML request. Request to get a list of  acceptance mechanisms from the ledger
     /// valid for specified time or the latest one.
     ///