Fix cryptocurrency and QA scripts (#965)

Fixed these scripts (that allow to launch a non-packaged app through `cargo run`)
by introducing an optional command line argument allowing to override java.library.path.
If it is not specified — <executable location>/lib/native is used.

Author: skletsun

exonum-java-binding/core/rust/exonum-java/start_cryptocurrency_node.sh

@@ -45,9 +45,7 @@ echo "${SERVICE_NAME} = '${ARTIFACT_PATH}'" >> ${SERVICES_CONFIG_FILE}
 header "PREPARE PATHS"
 
 EJB_LOG_CONFIG_PATH="${EJB_APP_DIR}/log4j-fallback.xml"
-
-export LD_LIBRARY_PATH="$JAVA_LIB_DIR"
-echo "LD_LIBRARY_PATH=${LD_LIBRARY_PATH}"
+JAVA_LIBRARY_PATH="${EJB_ROOT}/core/rust/target/debug"
 
 # Clear test dir
 rm -rf testnet
@@ -78,4 +76,5 @@ cargo +$RUST_COMPILER_VERSION run -- run -d testnet/db -c testnet/node.toml \
  --service-key-pass pass \
  --public-api-address 127.0.0.1:3000 \
  --ejb-log-config-path $EJB_LOG_CONFIG_PATH \
- --ejb-port 7000
+ --ejb-port 7000 \
+ --ejb-override-java-library-path $JAVA_LIBRARY_PATH

exonum-java-binding/core/rust/exonum-java/start_qa_node.sh

@@ -32,8 +32,7 @@ echo "PROJ_ROOT=${EJB_ROOT}"
 
 source "${EJB_ROOT}/tests_profile"
 
-export LD_LIBRARY_PATH="${JAVA_LIB_DIR}"
-echo "LD_LIBRARY_PATH=${LD_LIBRARY_PATH}"
+java_library_path="${EJB_ROOT}/core/rust/target/debug"
 
 # Find the artifact
 ARTIFACT_PATH="$(find ${EJB_ROOT} -type f -name exonum-java-binding-qa-service-*-artifact.jar)"
@@ -104,7 +103,8 @@ do
      --consensus-key-pass pass \
      --service-key-pass pass \
      --public-api-address 0.0.0.0:${port} \
-     --private-api-address 0.0.0.0:${private_port} &
+     --private-api-address 0.0.0.0:${private_port} \
+     --ejb-override-java-library-path ${java_library_path} &
 
     echo "new node with ports: $port (public) and $private_port (private)"
 done

exonum-java-binding/core/rust/integration_tests/src/vm.rs

@@ -145,10 +145,11 @@ pub fn log4j_path() -> String {
 }
 
 fn libpath_option() -> String {
-    format!("-Djava.library.path={}", libpath())
+    format!("-Djava.library.path={}", java_library_path())
 }
 
-fn libpath() -> String {
+/// Returns path to the java_bindings library for native integration tests.
+pub fn java_library_path() -> String {
     let library_path = rust_project_root_dir()
         .join(target_path())
         .canonicalize()

exonum-java-binding/core/rust/integration_tests/tests/service_factory_adapter.rs

@@ -43,7 +43,7 @@ fn test_callbacks() {
 
     let run_command_ext = run_command_ext.unwrap();
     let arguments = run_command_ext.args();
-    assert_eq!(arguments.len(), 5);
+    assert_eq!(arguments.len(), 6);
 
     // Make sure another instance of JavaServiceFactoryAdapter does not extend the `Run` command.
     let mut one_more_adapter =

exonum-java-binding/core/rust/integration_tests/tests/service_runtime_bootstrap.rs

@@ -17,7 +17,7 @@
 extern crate integration_tests;
 extern crate java_bindings;
 
-use integration_tests::vm::{fakes_classpath, log4j_path};
+use integration_tests::vm::{fakes_classpath, java_library_path, log4j_path};
 use java_bindings::{Config, InternalConfig, JavaServiceRuntime, JvmConfig, RuntimeConfig};
 
 #[test]
@@ -35,6 +35,7 @@ fn bootstrap() {
         // Pass log4j path to avoid error messages of mis-configuration
         log_config_path: log4j_path(),
         port: 6300,
+        override_system_lib_path: None,
     };
 
     let config = Config {
@@ -44,7 +45,7 @@ fn bootstrap() {
 
     let internal_config = InternalConfig {
         system_class_path: fakes_classpath(),
-        system_lib_path: None,
+        system_lib_path: java_library_path(),
     };
 
     let runtime = JavaServiceRuntime::new(config, internal_config);

exonum-java-binding/core/rust/src/runtime/cmd.rs

@@ -31,6 +31,7 @@ use std::path::PathBuf;
 // Parameters for `run` command
 const EJB_LOG_CONFIG_PATH: &str = "EJB_LOG_CONFIG_PATH";
 const EJB_PORT: &str = "EJB_PORT";
+const EJB_OVERRIDE_LIBRARY_PATH: &str = "EJB_OVERRIDE_LIBRARY_PATH";
 const JVM_DEBUG_SOCKET: &str = "JVM_DEBUG_SOCKET";
 const JVM_ARGS_PREPEND: &str = "JVM_ARGS_PREPEND";
 const JVM_ARGS_APPEND: &str = "JVM_ARGS_APPEND";
@@ -62,6 +63,15 @@ impl CommandExtension for Run {
                 "ejb-log-config-path",
                 false,
             ),
+            Argument::new_named(
+                EJB_OVERRIDE_LIBRARY_PATH,
+                false,
+                "Overrides the standard path to native libraries, enabling running the non-packaged \
+                exonum-java application. Mostly for internal usage.",
+                None,
+                "ejb-override-java-library-path",
+                false,
+            ),
             Argument::new_named(
                 JVM_DEBUG_SOCKET,
                 false,
@@ -97,6 +107,7 @@ impl CommandExtension for Run {
             .arg(EJB_LOG_CONFIG_PATH)
             .unwrap_or_else(|_| get_path_to_default_log_config());
         let port = context.arg(EJB_PORT)?;
+        let override_system_lib_path = context.arg(EJB_OVERRIDE_LIBRARY_PATH).ok();
         let args_prepend: Vec<String> = context.arg_multiple(JVM_ARGS_PREPEND).unwrap_or_default();
         let args_append: Vec<String> = context.arg_multiple(JVM_ARGS_APPEND).unwrap_or_default();
         let jvm_debug_socket = context.arg(JVM_DEBUG_SOCKET).ok();
@@ -110,6 +121,7 @@ impl CommandExtension for Run {
         let runtime_config = RuntimeConfig {
             log_config_path,
             port,
+            override_system_lib_path,
         };
 
         let config = Config {

exonum-java-binding/core/rust/src/runtime/config.rs

@@ -55,17 +55,18 @@ pub struct RuntimeConfig {
     /// A port of the HTTP server for Java services.
     /// Must be distinct from the ports used by Exonum.
     pub port: i32,
+    /// Overridden path to native library if specified.
+    pub override_system_lib_path: Option<String>,
 }
 
 /// Internal EJB configuration.
 ///
 /// Not visible by user, used internally while initializing runtime.
-#[doc(hidden)] // For testing purposes only.
 pub struct InternalConfig {
     /// EJB system classpath.
     pub system_class_path: String,
     /// EJB library path.
-    pub system_lib_path: Option<String>,
+    pub system_lib_path: String,
 }
 
 /// Error returned while validating user-specified additional parameters for JVM.

exonum-java-binding/core/rust/src/runtime/java_service_runtime.rs

@@ -202,20 +202,19 @@ impl JavaServiceRuntime {
 
     /// Adds required EJB-related arguments to JVM configuration.
     fn add_required_arguments(
-        mut args_builder: InitArgsBuilder,
+        args_builder: InitArgsBuilder,
         runtime_config: &RuntimeConfig,
         internal_config: InternalConfig,
     ) -> InitArgsBuilder {
-        // We do not use system library path in tests, because an absolute path to the native
-        // library will be provided at compile time using RPATH.
-        if internal_config.system_lib_path.is_some() {
-            args_builder = args_builder.option(&format!(
-                "-Djava.library.path={}",
-                internal_config.system_lib_path.unwrap()
-            ));
-        }
+        // Use overridden system library path if any.
+        let system_lib_path = if runtime_config.override_system_lib_path.is_some() {
+            runtime_config.override_system_lib_path.clone().unwrap()
+        } else {
+            internal_config.system_lib_path
+        };
 
         args_builder
+            .option(&format!("-Djava.library.path={}", system_lib_path))
             .option(&format!(
                 "-Djava.class.path={}",
                 internal_config.system_class_path

exonum-java-binding/core/rust/src/runtime/service_factory_adapter.rs

@@ -18,11 +18,12 @@ use exonum::{
 };
 use runtime::{
     cmd::Run,
-    config::{Config, InternalConfig},
+    config::Config,
     java_service_runtime::JavaServiceRuntime,
     paths::{absolute_library_path, system_classpath},
 };
 use std::sync::{Once, ONCE_INIT};
+use InternalConfig;
 
 static mut JAVA_SERVICE_RUNTIME: Option<JavaServiceRuntime> = None;
 static JAVA_SERVICE_RUNTIME_INIT: Once = ONCE_INIT;
@@ -53,20 +54,25 @@ impl JavaServiceFactoryAdapter {
     fn get_or_create_java_service_runtime(config: Config) -> JavaServiceRuntime {
         // Initialize runtime if it wasn't created before.
         JAVA_SERVICE_RUNTIME_INIT.call_once(|| {
-            let internal_config = InternalConfig {
-                system_class_path: system_classpath(),
-                system_lib_path: Some(absolute_library_path()),
-            };
-
-            let runtime = JavaServiceRuntime::new(config, internal_config);
-            unsafe {
-                JAVA_SERVICE_RUNTIME = Some(runtime);
-            }
+            Self::create_runtime(config);
         });
 
         unsafe { JAVA_SERVICE_RUNTIME.clone() }
             .expect("Trying to return runtime, but it's uninitialized")
     }
+
+    // Actually creates the runtime. Should be called only once.
+    fn create_runtime(config: Config) {
+        let internal_config = InternalConfig {
+            system_class_path: system_classpath(),
+            system_lib_path: absolute_library_path(),
+        };
+
+        let runtime = JavaServiceRuntime::new(config, internal_config);
+        unsafe {
+            JAVA_SERVICE_RUNTIME = Some(runtime);
+        }
+    }
 }
 
 impl ServiceFactory for JavaServiceFactoryAdapter {
@@ -95,7 +101,7 @@ impl ServiceFactory for JavaServiceFactoryAdapter {
     }
 }
 
-// Returns the real command extension for the first call and `None` for any other call.
+// Returns `true` for the very first call, `false` otherwise.
 fn is_first_instance_created() -> bool {
     let mut is_first = false;
     FIRST_INSTANCE_CREATED.call_once(|| is_first = true);