Merge pull request hyperledger-indy#668 from hyperledger/feature/payments

Feature Payments

Author: Vyacheslav

Jenkinsfile.cd

@@ -266,6 +266,7 @@ def windowsTesting() {
                                 "PATH=$WORKSPACE\\libindy\\prebuilt\\lib;$PATH",
                                 "RUST_BACKTRACE=1"
                         ]) {
+                            bat "cargo build --release"
                             bat "cargo test --release --no-run"
 
                             echo "Windows Libindy Test: Run tests"

Jenkinsfile.ci

@@ -45,6 +45,7 @@ def windowsTesting() {
                                 "PATH=$WORKSPACE\\libindy\\prebuilt\\lib;$PATH",
                                 "RUST_BACKTRACE=1"
                         ]) {
+                            bat "cargo build"
                             bat "cargo test --no-run"
 
                             echo "Windows Libindy Test: Run tests"
@@ -113,6 +114,7 @@ def macosTesting() {
                     setupRust()
                     setupBrewPackages()
                     sh "cargo build"
+                    sh "cargo test --no-run"
                     // TODO testing
                 }
 

cli/Cargo.lock

@@ -3,13 +3,17 @@ name = "indy-cli"
 version = "0.1.0"
 authors = ["Vyacheslav Gudkov <[email protected]>"]
 
+[features]
+payments_cli_tests = []
+
 [dependencies]
 ansi_term = "0.10"
 chrono = "0.4"
 env_logger = "0.4"
 unescape = "0.1"
 lazy_static = "0.2"
 libc = "0.2"
+libloading = "0.5.0"
 linefeed = "0.3"
 log = "0.3"
 prettytable-rs = "0.6.7"

cli/Cargo.toml

@@ -1,4 +1,5 @@
 extern crate rpassword;
+extern crate libloading;
 
 use unescape::unescape;
 
@@ -140,6 +141,7 @@ pub struct CommandContext {
     is_exit: RefCell<bool>,
     int_values: RefCell<HashMap<&'static str, i32>>,
     string_values: RefCell<HashMap<&'static str, String>>,
+    plugins: RefCell<HashMap<String, libloading::Library>>,
 }
 
 #[allow(dead_code)] //FIXME
@@ -151,6 +153,7 @@ impl CommandContext {
             is_exit: RefCell::new(false),
             int_values: RefCell::new(HashMap::new()),
             string_values: RefCell::new(HashMap::new()),
+            plugins: RefCell::new(HashMap::new()),
         }
     }
 
@@ -210,6 +213,11 @@ impl CommandContext {
     pub fn get_string_value(&self, key: &'static str) -> Option<String> {
         self.string_values.borrow().get(key).map(String::to_owned)
     }
+
+    pub fn add_plugin(&self, plugin_name: &str, plugin: libloading::Library) {
+        //TODO check already exists. Also check libindy
+        self.plugins.borrow_mut().insert(plugin_name.to_string(), plugin);
+    }
 }
 
 pub type CommandParams = HashMap<&'static str, String>;
@@ -345,6 +353,24 @@ impl CommandExecutor {
         completes
     }
 
+    fn rest_command_params(command: &Command, params: &Vec<&str>, word: &str) -> Vec<(String, char)> {
+        let mut completes: Vec<(String, char)> = Vec::new();
+
+        let command_params = command
+            .metadata()
+            .params();
+
+        let param_names: Vec<(String, char)> = command_params
+            .iter()
+            .filter(|param_meta| !params.contains(&param_meta.name) && param_meta.name.starts_with(word))
+            .map(|param_meta| ((*param_meta.name).to_owned(), '='))
+            .collect();
+
+        completes.extend(param_names);
+
+        completes
+    }
+
     fn command_names(commands: &HashMap<&'static str, Command>, word: &str) -> Vec<(String, char)> {
         commands
             .iter()
@@ -403,6 +429,10 @@ impl CommandExecutor {
             }
             (Some(first_word), Some(second_word), None) => {
                 match (first_word, second_word) {
+                    (_, sub_command) if sub_command == "help" => {}
+                    (command, params) if self.commands.contains_key(command) => {
+                        completes.extend(CommandExecutor::rest_command_params(&self.commands[command], &vec![params], word));
+                    }
                     (command, sub_command) if self.grouped_commands.contains_key(command) &&
                         CommandExecutor::is_subcommand(&self.grouped_commands, command, sub_command) => {
                         let (_, ref commands) = self.grouped_commands[command];
@@ -420,6 +450,14 @@ impl CommandExecutor {
                     _ => {}
                 }
             }
+            (Some(first_word), None, Some(params)) => {
+                match (first_word, &params) {
+                    (command, params) if self.commands.contains_key(command) => {
+                        completes.extend(CommandExecutor::rest_command_params(&self.commands[command], params, word));
+                    }
+                    _ => {}
+                }
+            }
             (Some(first_word), Some(second_word), Some(params)) => {
                 match (first_word, second_word, &params) {
                     (_, _, ref params) if "help".starts_with(params[0]) => {
@@ -431,17 +469,7 @@ impl CommandExecutor {
                         CommandExecutor::is_subcommand(&self.grouped_commands, command, sub_command) => {
                         let (_, ref commands) = self.grouped_commands[command];
                         let sub_command = commands.get(sub_command).unwrap();
-                        let command_params = sub_command
-                            .metadata()
-                            .params();
-
-                        let param_names: Vec<(String, char)> = command_params
-                            .iter()
-                            .filter(|param_meta| !params.contains(&param_meta.name) && param_meta.name.starts_with(word))
-                            .map(|param_meta| ((*param_meta.name).to_owned(), '='))
-                            .collect();
-
-                        completes.extend(param_names);
+                        completes.extend(CommandExecutor::rest_command_params(&sub_command, params, word));
                     }
                     _ => {}
                 }
@@ -714,11 +742,18 @@ impl CommandExecutor {
     fn _split_arguments(s: &str) -> (Option<&str>, Option<&str>, Option<Vec<&str>>) {
         let mut parts = s.trim().split_whitespace();
         let first_word = parts.next();
-        let second_word = parts.next();
-        let params = parts
+        let mut second_word = parts.next();
+        let mut params = parts
             .map(|s| s.split("=").collect::<Vec<&str>>()[0])
             .collect::<Vec<&str>>();
 
+        if let Some(s_word) = second_word {
+            if s_word.contains("=") {
+                params.insert(0, s_word.split("=").collect::<Vec<&str>>()[0]);
+                second_word = None;
+            }
+        }
+
         (first_word, second_word, if params.is_empty() { None } else { Some(params) })
     }
 

cli/src/command_executor.rs

@@ -1,3 +1,7 @@
+extern crate libloading;
+
+use libindy::ErrorCode;
+
 use command_executor::{Command, CommandContext, CommandParams, CommandMetadata, CommandResult};
 use commands::get_str_param;
 
@@ -84,6 +88,49 @@ pub mod prompt_command {
     }
 }
 
+pub mod load_plugin_command {
+    use super::*;
+
+    command!(CommandMetadata::build("load-plugin", "Load plugin in Libindy")
+                            .add_required_param("library", "Name of plugin (can be absolute or relative path)")
+                            .add_required_param("initializer", "Name of plugin init function")
+                            .add_example("load-plugin library=libsovtoken initializer=sovtoken_init")
+                            .finalize());
+
+    fn execute(_ctx: &CommandContext, params: &CommandParams) -> CommandResult {
+        trace!("execute >> params: {:?}", params);
+
+        let library = get_str_param("library", params).map_err(error_err!())?;
+        let initializer = get_str_param("initializer", params).map_err(error_err!())?;
+
+        let res = load_plugin(_ctx, library, initializer)?;
+
+        trace!("execute << {:?}", res);
+
+        Ok(res)
+    }
+}
+
+pub fn load_plugin(ctx: &CommandContext, library: &str, initializer: &str) -> Result<(), ()> {
+    let lib = libloading::Library::new(library)
+        .map_err(|_| println_err!("Plugin not found: \"{:?}\"", library))?;
+
+    unsafe {
+        let init_func: libloading::Symbol<unsafe extern fn() -> ErrorCode> = lib.get(initializer.as_bytes())
+            .map_err(|_| println_err!("Init function not found"))?;
+
+        match init_func() {
+            ErrorCode::Success => println_succ!("Plugin has been loaded: \"{}\"", library),
+            _ => println_err!("Plugin has not been loaded: \"{}\"", library)
+        }
+    }
+
+    //TODO think more about behaviour in case of init_func failed
+    ctx.add_plugin(library, lib);
+
+    Ok(())
+}
+
 pub mod exit_command {
     use super::*;
 
@@ -98,4 +145,38 @@ pub mod exit_command {
         trace!("execute << {:?}", res);
         res
     }
+}
+
+#[cfg(test)]
+pub mod tests {
+    use super::*;
+
+    pub const NULL_PAYMENT_METHOD: &'static str = "null";
+    pub const NULL_PAYMENT_PLUGIN: &'static str = "libnullpay.so";
+    pub const NULL_PAYMENT_PLUGIN_INIT_FUNCTION: &'static str = "nullpay_init";
+
+    mod load {
+        use super::*;
+
+        #[test]
+        #[cfg(feature = "payments_cli_tests")]
+        pub fn load_works() {
+            let ctx = CommandContext::new();
+
+            let cmd = load_plugin_command::new();
+            let mut params = CommandParams::new();
+            params.insert("library", NULL_PAYMENT_PLUGIN.to_string());
+            params.insert("initializer", NULL_PAYMENT_PLUGIN_INIT_FUNCTION.to_string());
+            cmd.execute(&ctx, &params).unwrap();
+        }
+    }
+
+    pub fn load_null_payment_plugin(ctx: &CommandContext) -> () {
+        let lib = libloading::Library::new(NULL_PAYMENT_PLUGIN).unwrap();
+        unsafe {
+            let init_func: libloading::Symbol<unsafe extern fn() -> ErrorCode> = lib.get(NULL_PAYMENT_PLUGIN_INIT_FUNCTION.as_bytes()).unwrap();
+            init_func();
+        }
+        ctx.add_plugin(NULL_PAYMENT_PLUGIN, lib)
+    }
 }

cli/src/commands/common.rs

@@ -228,7 +228,7 @@ pub mod rotate_key_command {
                 handle_transaction_response(response)?;
             }
             Err(err) => {
-                handle_transaction_error(err, Some(&did), Some(&pool_name), Some(&wallet_name))?;
+                handle_transaction_error(err, Some(&did), Some(&pool_name), Some(&wallet_name));
             }
         };