universa 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d82dc409f3c6d9edbc061c16dac9484dc527c9c906add7e524d2a890adcf8f4f
-  data.tar.gz: c6c0c5b3de7ab37e6fbe05b1758e47f14f2f443038a580edf4d398f2ab6e53f5
+  metadata.gz: 6b0550e986188ea0c6777ed4e08112e5cbf3605b7247b11ee939a5c8b3944fcf
+  data.tar.gz: 56278bf8d1271447de7acde7cf85c98086c994f3635b966c104d00cb5cbb1fa6
 SHA512:
-  metadata.gz: 89923e2f4ee761b0d453b94a0e2cf2f160ce900b8f9dccfc09da468eee52064c970aa9a0df63a4fe031accedf318f267141d6a83c48e3009bad80f123ab1efca
-  data.tar.gz: 5a386e95f89146c5b2d506ee9b7f01a80b9fca7d2ba42fb36f65a34dd95ea2449af64e96fca71fe06980f08928269ee18b8686035a701eadb7bcb1987708020e
+  metadata.gz: 3f1b071d7ae76fed9b9879ed03e4a106f614f1a4c420e58c8b7e3e23b84b9f3b87688c9eece8a4c7485e411f49388e23d9c76da90579721f00c5bff98f6f67dc
+  data.tar.gz: 4da0d67c5ada6d480fa3868294993a55c2db072f29e1982f57d26c1402c59a3099967cc3d006ba097fa5e72bdc775d580a4c8869cfe8dcff5085f483b60f3715

data/.gitignore

@@ -11,3 +11,4 @@
 # rspec failure tracking
 .rspec_status
 Gemfile.lock
+/sessionlog.txt

data/README.md

@@ -1,9 +1,9 @@
 # Universa
 
-> This version is a placeholder. It is not yet functional.
+> Alfa state: direct access to Java API ready for test. 
 
 This is an under-construction official gem from [Universa][universa] that will facilitate access to the
-Java library using Universa's RMI protocol.  
+Java library using Universa's UMI protocol.  
 
 ## Installation
 
@@ -29,7 +29,27 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+So far, you can only get direct access the the Java API functions. To get it:
+
+```ruby
+require 'universa'
+
+umi = Universa::UMI.new
+
+p umi.version                                         #=> "0.8.7"
+key = umi.instantiate "PrivateKey", 2048
+contract = umi.instantiate "Contract", key
+sealed = contract.seal()
+puts "Contract is ok: #{contract.check()}"            #=> contract is ok: true"
+puts "Contract id: #{contract.getId.toBase64String}"  #=> contract id: x9Ey+q...
+```
+
+for more information see:
+
+- [Universa gem page](https://kb.universa.io/universa_ruby_gem/131) in the Universa Knowledge Base.
+- Universa Java API: https://kb.universa.io/general_java_api/5 
+- Universa UMI server: https://kb.universa.io/umi_protocol/98
+- Farcall [gem](https://github.com/sergeych/farcall) and [protocol](https://github.com/sergeych/farcall/wiki).
 
 ## Development
 

data/bin/refresh_umi

@@ -0,0 +1,20 @@
+#!/bin/bash
+
+rm download > /dev/null
+
+wget https://files.universa.io/s/ecz6fDT7ny634Xj/download
+
+rm -rd -f ./bin/umi >/dev/null 2>&1
+rm -rd -f ./bin/umi-* >/dev/null 2>&1
+
+echo "preparing..."
+
+unzip download -d ./bin >/dev/null
+
+mv ./bin/umi-* ./bin/umi >/dev/null
+rm -rd ./bin/__MACOSX >/dev/null 2>&1
+
+rm download
+
+echo "done!"
+

data/bin/umi/bin/umi

@@ -0,0 +1,355 @@
+#!/usr/bin/env bash
+
+###  ------------------------------- ###
+###  Helper methods for BASH scripts ###
+###  ------------------------------- ###
+
+die() {
+  echo "$@" 1>&2
+  exit 1
+}
+
+realpath () {
+(
+  TARGET_FILE="$1"
+  CHECK_CYGWIN="$2"
+
+  cd "$(dirname "$TARGET_FILE")"
+  TARGET_FILE=$(basename "$TARGET_FILE")
+
+  COUNT=0
+  while [ -L "$TARGET_FILE" -a $COUNT -lt 100 ]
+  do
+      TARGET_FILE=$(readlink "$TARGET_FILE")
+      cd "$(dirname "$TARGET_FILE")"
+      TARGET_FILE=$(basename "$TARGET_FILE")
+      COUNT=$(($COUNT + 1))
+  done
+
+  if [ "$TARGET_FILE" == "." -o "$TARGET_FILE" == ".." ]; then
+    cd "$TARGET_FILE"
+    TARGET_FILEPATH=
+  else
+    TARGET_FILEPATH=/$TARGET_FILE
+  fi
+
+  # make sure we grab the actual windows path, instead of cygwin's path.
+  if [[ "x$CHECK_CYGWIN" == "x" ]]; then
+    echo "$(pwd -P)/$TARGET_FILE"
+  else
+    echo $(cygwinpath "$(pwd -P)/$TARGET_FILE")
+  fi
+)
+}
+
+# TODO - Do we need to detect msys?
+
+# Uses uname to detect if we're in the odd cygwin environment.
+is_cygwin() {
+  local os=$(uname -s)
+  case "$os" in
+    CYGWIN*) return 0 ;;
+    *)  return 1 ;;
+  esac
+}
+
+# This can fix cygwin style /cygdrive paths so we get the
+# windows style paths.
+cygwinpath() {
+  local file="$1"
+  if is_cygwin; then
+    echo $(cygpath -w $file)
+  else
+    echo $file
+  fi
+}
+
+# Make something URI friendly
+make_url() {
+  url="$1"
+  local nospaces=${url// /%20}
+  if is_cygwin; then
+    echo "/${nospaces//\\//}"
+  else
+    echo "$nospaces"
+  fi
+}
+
+# This crazy function reads in a vanilla "linux" classpath string (only : are separators, and all /),
+# and returns a classpath with windows style paths, and ; separators.
+fixCygwinClasspath() {
+  OLDIFS=$IFS
+  IFS=":"
+  read -a classpath_members <<< "$1"
+  declare -a fixed_members
+  IFS=$OLDIFS
+  for i in "${!classpath_members[@]}"
+  do
+    fixed_members[i]=$(realpath "${classpath_members[i]}" "fix")
+  done
+  IFS=";"
+  echo "${fixed_members[*]}"
+  IFS=$OLDIFS
+}
+
+# Fix the classpath we use for cygwin.
+fix_classpath() {
+  cp="$1"
+  if is_cygwin; then
+    echo "$(fixCygwinClasspath "$cp")"
+  else
+    echo "$cp"
+  fi
+}
+# Detect if we should use JAVA_HOME or just try PATH.
+get_java_cmd() {
+  if [[ -n "$JAVA_HOME" ]] && [[ -x "$JAVA_HOME/bin/java" ]];  then
+    echo "$JAVA_HOME/bin/java"
+  else
+    echo "java"
+  fi
+}
+
+echoerr () {
+  echo 1>&2 "$@"
+}
+vlog () {
+  [[ $verbose || $debug ]] && echoerr "$@"
+}
+dlog () {
+  [[ $debug ]] && echoerr "$@"
+}
+execRunner () {
+  # print the arguments one to a line, quoting any containing spaces
+  [[ $verbose || $debug ]] && echo "# Executing command line:" && {
+    for arg; do
+      if printf "%s\n" "$arg" | grep -q ' '; then
+        printf "\"%s\"\n" "$arg"
+      else
+        printf "%s\n" "$arg"
+      fi
+    done
+    echo ""
+  }
+
+  # we use "exec" here for our pids to be accurate.
+  exec "$@"
+}
+addJava () {
+  dlog "[addJava] arg = '$1'"
+  java_args+=( "$1" )
+}
+addApp () {
+  dlog "[addApp] arg = '$1'"
+  app_commands+=( "$1" )
+}
+addResidual () {
+  dlog "[residual] arg = '$1'"
+  residual_args+=( "$1" )
+}
+addDebugger () {
+  addJava "-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=$1"
+}
+
+require_arg () {
+  local type="$1"
+  local opt="$2"
+  local arg="$3"
+  if [[ -z "$arg" ]] || [[ "${arg:0:1}" == "-" ]]; then
+    die "$opt requires <$type> argument"
+  fi
+}
+is_function_defined() {
+  declare -f "$1" > /dev/null
+}
+
+# Attempt to detect if the script is running via a GUI or not
+# TODO - Determine where/how we use this generically
+detect_terminal_for_ui() {
+  [[ ! -t 0 ]] && [[ "${#residual_args}" == "0" ]] && {
+    echo "true"
+  }
+  # SPECIAL TEST FOR MAC
+  [[ "$(uname)" == "Darwin" ]] && [[ "$HOME" == "$PWD" ]] && [[ "${#residual_args}" == "0" ]] && {
+    echo "true"
+  }
+}
+
+# Processes incoming arguments and places them in appropriate global variables.  called by the run method.
+process_args () {
+  local no_more_snp_opts=0
+  while [[ $# -gt 0 ]]; do
+    case "$1" in
+             --) shift && no_more_snp_opts=1 && break ;;
+       -h|-help) usage; exit 1 ;;
+    -v|-verbose) verbose=1 && shift ;;
+      -d|-debug) debug=1 && shift ;;
+
+    -no-version-check) no_version_check=1 && shift ;;
+
+           -mem) echo "!! WARNING !! -mem option is ignored. Please use -J-Xmx and -J-Xms" && shift 2 ;;
+     -jvm-debug) require_arg port "$1" "$2" && addDebugger $2 && shift 2 ;;
+
+          -main) custom_mainclass="$2" && shift 2 ;;
+
+     -java-home) require_arg path "$1" "$2" && jre=`eval echo $2` && java_cmd="$jre/bin/java" && shift 2 ;;
+
+ -D*|-agentlib*|-XX*) addJava "$1" && shift ;;
+                 -J*) addJava "${1:2}" && shift ;;
+                   *) addResidual "$1" && shift ;;
+    esac
+  done
+
+  if [[ no_more_snp_opts ]]; then
+    while [[ $# -gt 0 ]]; do
+      addResidual "$1" && shift
+    done
+  fi
+
+  is_function_defined process_my_args && {
+    myargs=("${residual_args[@]}")
+    residual_args=()
+    process_my_args "${myargs[@]}"
+  }
+}
+
+# Actually runs the script.
+run() {
+  # TODO - check for sane environment
+
+  # process the combined args, then reset "$@" to the residuals
+  process_args "$@"
+  set -- "${residual_args[@]}"
+  argumentCount=$#
+
+  #check for jline terminal fixes on cygwin
+  if is_cygwin; then
+    stty -icanon min 1 -echo > /dev/null 2>&1
+    addJava "-Djline.terminal=jline.UnixTerminal"
+    addJava "-Dsbt.cygwin=true"
+  fi
+
+  # check java version
+  if [[ ! $no_version_check ]]; then
+    java_version_check
+  fi
+
+  if [ -n "$custom_mainclass" ]; then
+    mainclass=("$custom_mainclass")
+  else
+    mainclass=("${app_mainclass[@]}")
+  fi
+
+  # Now we check to see if there are any java opts on the environment. These get listed first, with the script able to override them.
+  if [[ "$JAVA_OPTS" != "" ]]; then
+    java_opts="${JAVA_OPTS}"
+  fi
+
+  # run sbt
+  execRunner "$java_cmd" \
+    ${java_opts[@]} \
+    "${java_args[@]}" \
+    -cp "$(fix_classpath "$app_classpath")" \
+    "${mainclass[@]}" \
+    "${app_commands[@]}" \
+    "${residual_args[@]}"
+
+  local exit_code=$?
+  if is_cygwin; then
+    stty icanon echo > /dev/null 2>&1
+  fi
+  exit $exit_code
+}
+
+# Loads a configuration file full of default command line options for this script.
+loadConfigFile() {
+  cat "$1" | sed $'/^\#/d;s/\r$//'
+}
+
+# Now check to see if it's a good enough version
+# TODO - Check to see if we have a configured default java version, otherwise use 1.6
+java_version_check() {
+  readonly java_version=$("$java_cmd" -version 2>&1 | awk -F '"' '/version/ {print $2}')
+  if [[ "$java_version" == "" ]]; then
+    echo
+    echo No java installations was detected.
+    echo Please go to http://www.java.com/getjava/ and download
+    echo
+    exit 1
+  else
+    local major=$(echo "$java_version" | cut -d'.' -f1)
+    if [[ "$major" -eq "1" ]]; then
+     local major=$(echo "$java_version" | cut -d'.' -f2)
+    fi
+    if [[ "$major" -lt "6" ]]; then
+      echo
+      echo The java installation you have is not up to date
+      echo $app_name requires at least version 1.6+, you have
+      echo version $java_version
+      echo
+      echo Please go to http://www.java.com/getjava/ and download
+      echo a valid Java Runtime and install before running $app_name.
+      echo
+      exit 1
+    fi
+  fi
+}
+
+###  ------------------------------- ###
+###  Start of customized settings    ###
+###  ------------------------------- ###
+usage() {
+ cat <<EOM
+Usage: $script_name [options]
+
+  -h | -help         print this message
+  -v | -verbose      this runner is chattier
+  -d | -debug        set sbt log level to debug
+  -no-version-check  Don't run the java version check.
+  -main <classname>  Define a custom main class
+  -jvm-debug <port>  Turn on JVM debugging, open at the given port.
+
+  # java version (default: java from PATH, currently $(java -version 2>&1 | grep version))
+  -java-home <path>         alternate JAVA_HOME
+
+  # jvm options and output control
+  JAVA_OPTS          environment variable, if unset uses "$java_opts"
+  -Dkey=val          pass -Dkey=val directly to the java runtime
+  -J-X               pass option -X directly to the java runtime
+                     (-J is stripped)
+
+  # special option
+  --                 To stop parsing built-in commands from the rest of the command-line.
+                     e.g.) enabling debug and sending -d as app argument
+                     \$ ./start-script -d -- -d
+
+In the case of duplicated or conflicting options, basically the order above
+shows precedence: JAVA_OPTS lowest, command line options highest except "--".
+Available main classes:
+	com.icodici.farcallscala.Main
+EOM
+}
+
+###  ------------------------------- ###
+###  Main script                     ###
+###  ------------------------------- ###
+
+declare -a residual_args
+declare -a java_args
+declare -a app_commands
+declare -r real_script_path="$(realpath "$0")"
+declare -r app_home="$(realpath "$(dirname "$real_script_path")")"
+# TODO - Check whether this is ok in cygwin...
+declare -r lib_dir="$(realpath "${app_home}/../lib")"
+declare -a app_mainclass=(com.icodici.farcallscala.Main)
+
+declare -r script_conf_file="${app_home}/../conf/application.ini"
+declare -r app_classpath="$lib_dir/com.icodici.umi-0.8.7.jar:$lib_dir/org.scala-lang.scala-library-2.12.7.jar:$lib_dir/com.icodici.universa_core-3.8.3.jar:$lib_dir/org.yaml.snakeyaml-1.18.jar:$lib_dir/net.sf.jopt-simple.jopt-simple-4.9.jar:$lib_dir/org.postgresql.postgresql-42.1.4.jar:$lib_dir/org.xerial.sqlite-jdbc-3.8.9.1.jar:$lib_dir/com.icodici.nanohttpd-2.1.0.jar:$lib_dir/com.icodici.common_tools-3.8.3.jar:$lib_dir/com.eclipsesource.minimal-json.minimal-json-0.9.4.jar:$lib_dir/net.java.dev.jna.jna-4.5.1.jar:$lib_dir/org.checkerframework.checker-qual-2.3.2.jar:$lib_dir/com.icodici.crypto-3.8.3.jar:$lib_dir/com.madgag.spongycastle.core-1.58.0.0.jar:$lib_dir/com.squareup.jnagmp.jnagmp-2.0.0.jar:$lib_dir/com.typesafe.play.play-json_2.12-2.6.10.jar:$lib_dir/com.typesafe.play.play-functional_2.12-2.6.10.jar:$lib_dir/org.scala-lang.scala-reflect-2.12.7.jar:$lib_dir/org.typelevel.macro-compat_2.12-1.1.1.jar:$lib_dir/joda-time.joda-time-2.9.9.jar:$lib_dir/com.fasterxml.jackson.core.jackson-core-2.8.11.jar:$lib_dir/com.fasterxml.jackson.core.jackson-annotations-2.8.11.jar:$lib_dir/com.fasterxml.jackson.datatype.jackson-datatype-jdk8-2.8.11.jar:$lib_dir/com.fasterxml.jackson.core.jackson-databind-2.8.11.1.jar:$lib_dir/com.fasterxml.jackson.datatype.jackson-datatype-jsr310-2.8.11.jar:$lib_dir/org.scala-sbt.ipcsocket.ipcsocket-1.0.0.jar:$lib_dir/net.java.dev.jna.jna-platform-4.5.0.jar"
+
+# java_cmd is overrode in process_args when -java-home is used
+declare java_cmd=$(get_java_cmd)
+
+# if configuration files exist, prepend their contents to $@ so it can be processed by this runner
+[[ -f "$script_conf_file" ]] && set -- $(loadConfigFile "$script_conf_file") "$@"
+
+run "$@"

data/bin/umi/bin/umi.bat

@@ -0,0 +1,180 @@
+@REM umi launcher script
+@REM
+@REM Environment:
+@REM JAVA_HOME - location of a JDK home dir (optional if java on path)
+@REM CFG_OPTS  - JVM options (optional)
+@REM Configuration:
+@REM UMI_config.txt found in the UMI_HOME.
+@setlocal enabledelayedexpansion
+
+@echo off
+
+
+if "%UMI_HOME%"=="" (
+  set "APP_HOME=%~dp0\\.."
+
+  rem Also set the old env name for backwards compatibility
+  set "UMI_HOME=%~dp0\\.."
+) else (
+  set "APP_HOME=%UMI_HOME%"
+)
+
+set "APP_LIB_DIR=%APP_HOME%\lib\"
+
+rem Detect if we were double clicked, although theoretically A user could
+rem manually run cmd /c
+for %%x in (!cmdcmdline!) do if %%~x==/c set DOUBLECLICKED=1
+
+rem FIRST we load the config file of extra options.
+set "CFG_FILE=%APP_HOME%\UMI_config.txt"
+set CFG_OPTS=
+call :parse_config "%CFG_FILE%" CFG_OPTS
+
+rem We use the value of the JAVACMD environment variable if defined
+set _JAVACMD=%JAVACMD%
+
+if "%_JAVACMD%"=="" (
+  if not "%JAVA_HOME%"=="" (
+    if exist "%JAVA_HOME%\bin\java.exe" set "_JAVACMD=%JAVA_HOME%\bin\java.exe"
+  )
+)
+
+if "%_JAVACMD%"=="" set _JAVACMD=java
+
+rem Detect if this java is ok to use.
+for /F %%j in ('"%_JAVACMD%" -version  2^>^&1') do (
+  if %%~j==java set JAVAINSTALLED=1
+  if %%~j==openjdk set JAVAINSTALLED=1
+)
+
+rem BAT has no logical or, so we do it OLD SCHOOL! Oppan Redmond Style
+set JAVAOK=true
+if not defined JAVAINSTALLED set JAVAOK=false
+
+if "%JAVAOK%"=="false" (
+  echo.
+  echo A Java JDK is not installed or can't be found.
+  if not "%JAVA_HOME%"=="" (
+    echo JAVA_HOME = "%JAVA_HOME%"
+  )
+  echo.
+  echo Please go to
+  echo   http://www.oracle.com/technetwork/java/javase/downloads/index.html
+  echo and download a valid Java JDK and install before running umi.
+  echo.
+  echo If you think this message is in error, please check
+  echo your environment variables to see if "java.exe" and "javac.exe" are
+  echo available via JAVA_HOME or PATH.
+  echo.
+  if defined DOUBLECLICKED pause
+  exit /B 1
+)
+
+
+rem We use the value of the JAVA_OPTS environment variable if defined, rather than the config.
+set _JAVA_OPTS=%JAVA_OPTS%
+if "!_JAVA_OPTS!"=="" set _JAVA_OPTS=!CFG_OPTS!
+
+rem We keep in _JAVA_PARAMS all -J-prefixed and -D-prefixed arguments
+rem "-J" is stripped, "-D" is left as is, and everything is appended to JAVA_OPTS
+set _JAVA_PARAMS=
+set _APP_ARGS=
+
+set "APP_CLASSPATH=%APP_LIB_DIR%\com.icodici.umi-0.8.7.jar;%APP_LIB_DIR%\org.scala-lang.scala-library-2.12.7.jar;%APP_LIB_DIR%\com.icodici.universa_core-3.8.3.jar;%APP_LIB_DIR%\org.yaml.snakeyaml-1.18.jar;%APP_LIB_DIR%\net.sf.jopt-simple.jopt-simple-4.9.jar;%APP_LIB_DIR%\org.postgresql.postgresql-42.1.4.jar;%APP_LIB_DIR%\org.xerial.sqlite-jdbc-3.8.9.1.jar;%APP_LIB_DIR%\com.icodici.nanohttpd-2.1.0.jar;%APP_LIB_DIR%\com.icodici.common_tools-3.8.3.jar;%APP_LIB_DIR%\com.eclipsesource.minimal-json.minimal-json-0.9.4.jar;%APP_LIB_DIR%\net.java.dev.jna.jna-4.5.1.jar;%APP_LIB_DIR%\org.checkerframework.checker-qual-2.3.2.jar;%APP_LIB_DIR%\com.icodici.crypto-3.8.3.jar;%APP_LIB_DIR%\com.madgag.spongycastle.core-1.58.0.0.jar;%APP_LIB_DIR%\com.squareup.jnagmp.jnagmp-2.0.0.jar;%APP_LIB_DIR%\com.typesafe.play.play-json_2.12-2.6.10.jar;%APP_LIB_DIR%\com.typesafe.play.play-functional_2.12-2.6.10.jar;%APP_LIB_DIR%\org.scala-lang.scala-reflect-2.12.7.jar;%APP_LIB_DIR%\org.typelevel.macro-compat_2.12-1.1.1.jar;%APP_LIB_DIR%\joda-time.joda-time-2.9.9.jar;%APP_LIB_DIR%\com.fasterxml.jackson.core.jackson-core-2.8.11.jar;%APP_LIB_DIR%\com.fasterxml.jackson.core.jackson-annotations-2.8.11.jar;%APP_LIB_DIR%\com.fasterxml.jackson.datatype.jackson-datatype-jdk8-2.8.11.jar;%APP_LIB_DIR%\com.fasterxml.jackson.core.jackson-databind-2.8.11.1.jar;%APP_LIB_DIR%\com.fasterxml.jackson.datatype.jackson-datatype-jsr310-2.8.11.jar;%APP_LIB_DIR%\org.scala-sbt.ipcsocket.ipcsocket-1.0.0.jar;%APP_LIB_DIR%\net.java.dev.jna.jna-platform-4.5.0.jar"
+set "APP_MAIN_CLASS=com.icodici.farcallscala.Main"
+set "SCRIPT_CONF_FILE=%APP_HOME%\conf\application.ini"
+
+rem if configuration files exist, prepend their contents to the script arguments so it can be processed by this runner
+call :parse_config "%SCRIPT_CONF_FILE%" SCRIPT_CONF_ARGS
+
+call :process_args %SCRIPT_CONF_ARGS% %%*
+
+set _JAVA_OPTS=!_JAVA_OPTS! !_JAVA_PARAMS!
+
+if defined CUSTOM_MAIN_CLASS (
+    set MAIN_CLASS=!CUSTOM_MAIN_CLASS!
+) else (
+    set MAIN_CLASS=!APP_MAIN_CLASS!
+)
+
+rem Call the application and pass all arguments unchanged.
+"%_JAVACMD%" !_JAVA_OPTS! !UMI_OPTS! -cp "%APP_CLASSPATH%" %MAIN_CLASS% !_APP_ARGS!
+
+@endlocal
+
+exit /B %ERRORLEVEL%
+
+
+rem Loads a configuration file full of default command line options for this script.
+rem First argument is the path to the config file.
+rem Second argument is the name of the environment variable to write to.
+:parse_config
+  set _PARSE_FILE=%~1
+  set _PARSE_OUT=
+  if exist "%_PARSE_FILE%" (
+    FOR /F "tokens=* eol=# usebackq delims=" %%i IN ("%_PARSE_FILE%") DO (
+      set _PARSE_OUT=!_PARSE_OUT! %%i
+    )
+  )
+  set %2=!_PARSE_OUT!
+exit /B 0
+
+
+:add_java
+  set _JAVA_PARAMS=!_JAVA_PARAMS! %*
+exit /B 0
+
+
+:add_app
+  set _APP_ARGS=!_APP_ARGS! %*
+exit /B 0
+
+
+rem Processes incoming arguments and places them in appropriate global variables
+:process_args
+  :param_loop
+  call set _PARAM1=%%1
+  set "_TEST_PARAM=%~1"
+
+  if ["!_PARAM1!"]==[""] goto param_afterloop
+
+
+  rem ignore arguments that do not start with '-'
+  if "%_TEST_PARAM:~0,1%"=="-" goto param_java_check
+  set _APP_ARGS=!_APP_ARGS! !_PARAM1!
+  shift
+  goto param_loop
+
+  :param_java_check
+  if "!_TEST_PARAM:~0,2!"=="-J" (
+    rem strip -J prefix
+    set _JAVA_PARAMS=!_JAVA_PARAMS! !_TEST_PARAM:~2!
+    shift
+    goto param_loop
+  )
+
+  if "!_TEST_PARAM:~0,2!"=="-D" (
+    rem test if this was double-quoted property "-Dprop=42"
+    for /F "delims== tokens=1,*" %%G in ("!_TEST_PARAM!") DO (
+      if not ["%%H"] == [""] (
+        set _JAVA_PARAMS=!_JAVA_PARAMS! !_PARAM1!
+      ) else if [%2] neq [] (
+        rem it was a normal property: -Dprop=42 or -Drop="42"
+        call set _PARAM1=%%1=%%2
+        set _JAVA_PARAMS=!_JAVA_PARAMS! !_PARAM1!
+        shift
+      )
+    )
+  ) else (
+    if "!_TEST_PARAM!"=="-main" (
+      call set CUSTOM_MAIN_CLASS=%%2
+      shift
+    ) else (
+      set _APP_ARGS=!_APP_ARGS! !_PARAM1!
+    )
+  )
+  shift
+  goto param_loop
+  :param_afterloop
+
+exit /B 0

data/exe/universa

@@ -1,3 +1,9 @@
 #!/usr/bin/env ruby
 
 require "universa"
+
+
+puts "Checking prerequisites"
+
+puts "Found Unimi version: #{UMI.new.version}"
+

data/lib/universa/errors.rb

@@ -0,0 +1,25 @@
+module Universa
+
+  # Basic error reported by Universa library.
+  class Error < IOError
+  end
+
+  # references from different {UMI} instances are mixed together
+  class InterchangeError < Error
+    # create instance optionally overriding message
+    def initialize(text = "objects can't be interchanged between different UMI interfaces")
+      super(text)
+    end
+  end
+
+  # Easy print stack trace refinement
+  refine Exception do
+
+    # syntax sugar: print exception class, message and stack trace (with line feeds) to
+    # the stderr.
+    def print_stack_trace
+      STDERR.puts "Error (#{self.class.name}): #{self}"
+      STDERR.puts self.backtrace.join("\n")
+    end
+  end
+end

data/lib/universa/umi.rb

@@ -0,0 +1,373 @@
+require 'open3'
+require 'farcall'
+require 'base64'
+require 'weakref'
+require_relative 'weak_reference'
+
+using Universa
+
+module Universa
+
+  # Universa Method Invocation remote interface.
+  #
+  # By default, it creates UMI interface to the included UMI server which gives almost full access
+  # to the Universa Java API:
+  #
+  # Uasge:
+  #    >> umi = Universa::UMI.new()
+  #    >> # create a new key and new contract with this key as creator:
+  #    >> contract = umi.instantiate "Contract", umi.instantiate("PrivateKey", 2048)
+  #
+  # Use {#instantiate} to create new instances of remote classes, which return {Ref} instances,
+  # and just call their methods as if these are usual ruby methods. For example in the example above:
+  #
+  #    address = contract.getKeysToSignWith()[0].getPublicKey().getShortAddress().toString()
+  #
+  # In the sample above all the methods are called on the remote side, returning links to remote objects
+  # which are all {Ref} instances, and the last `toString()` call return a string, which is converted to
+  # ruby string and saved into variable. This sentence, therefore, get the first signer key and transofrms it
+  # to the string short address.
+  #
+  # == Having several `UMI` interfaces.
+  #
+  # It is possible to have several UMI instances, by default, it will create separate process with isolated
+  # data space, which is perfectly safe to use in various scenarios.
+  #
+  # It still means the object from different interfaces can't be interchanged. {Ref} instances created
+  # by one interface should be used with this interface only, or the {InterchangeError} will be raised.
+  #
+  # == Remote exceptions
+  #
+  # If remote part will thow an Exception performing a method, it will be raised as an instance of
+  # {https://www.rubydoc.info/gems/farcall/Farcall/RemoteError Farcall::RemoteError} class which carries remote
+  # exception information.
+  #
+  # == Transport level
+  #
+  # UMI uses {https://github.com/sergeych/farcall/wiki Farcall} transport in woth JSON adapter and "\n" as separator.
+  #
+  class UMI
+
+    ##
+    # Create UMI instance. It starts the private child process wit UMI server and securely connects to
+    # it so no other connection could occur.
+    #
+    #    # create UNI interface
+    #    umi = Universa::UMI.new()
+    #    # create a new key and new contract with this key as creator:
+    #    contract = umi.instantiate "Contract", umi.instantiate("PrivateKey", 2048)
+    #    contract.seal()  # binary packed string returned
+    #    contract.check() #=> true
+    #
+    # @param [String] path to custom UMI server build. Use bundled one (leave as nil)
+    # @param [Regexp] version_check check version against
+    # @param [String] system expected on the remote side. 'UMI' us a universa umi server.
+    def initialize(path = nil, version_check: /./, system: "UMI", log: 'sessionlog.txt')
+      path ||= File.expand_path(File.split(__FILE__)[0] + "/../../bin/umi/bin/umi")
+      @in, @out, @err, @wtr = Open3.popen3("#{path} #{log ? "-log #{log}" : ''}")
+      @endpoint = Farcall::Endpoint.new(
+          Farcall::JsonTransport.create(delimiter: "\n", input: @out, output: @in)
+      )
+      @lock = Monitor.new
+      @cache = {}
+      @closed = false
+      @references = {}
+      start_cleanup_queue
+      @version = call("version")
+      raise Error, "Unsupported system: #{@version}" if @version.system != "UMI"
+      raise Error, "Unsupported version: #{@version}" if @version.version !~ /0\.8\.\d+/
+    rescue Errno::ENOENT
+      @err and STDERR.puts @err.read
+      raise Error, "missing java binaries"
+    end
+
+    def version
+      @version.version
+    end
+
+    # Create instance of some Universa Java API class, for example 'Contract', passing any arguments
+    # to its constructor. The returned reference could be used much like local instance, nu the actual
+    # work will happen in the child process. Use references as much as possible as they take all the
+    # housekeeping required, like memory leaks prevention and direct method calling.
+    #
+    # @return [Ref] reference to the remotely created object. See {Ref}.
+    def instantiate(object_class_name, *args)
+      ensure_open
+      create_reference call("instantiate", object_class_name, *prepare_args(args))
+    end
+
+    # Invoke method by name. Should not be used directly; use {Ref} instance to call its methods.
+    def invoke(ref, method, *args)
+      ensure_open
+      ref._umi == self or raise InterchangeError
+      result = call("invoke", ref._remote_id, method, *prepare_args(args))
+      encode_result result
+    rescue
+      $!.print_stack_trace
+    end
+
+    # Close child process. No remote calls should occur after it.
+    def close
+      @queue.push :poison_pill
+      @cleanup_thread.join
+      @closed = true
+      @endpoint.close
+      @in.close
+      @out.close
+      @wtr.value.exited?
+    end
+
+    # short data label for UMI interface
+    def inspect
+      "<UniMI:#{__id__}:#{version}>"
+    end
+
+    # debug use only. Looks for the cached e.g. (alive) remote object. Does not check
+    # the remote side.
+    def find_by_remote_id remote_id
+      @lock.synchronize {@cache[remote_id]&.get}
+    end
+
+    # Execute the block with trace mode on. Will spam the output with protocol information.
+    # These calls could be nested, on exit it restores previous trace state
+    def with_trace &block
+      current_state, @trace = @trace, true
+      block.call()
+      @trace = current_state
+    end
+
+    private
+
+    # create a finalizer that will drop remote object
+    def create_finalizer(remote_id)
+      -> (id) {
+        begin
+          @lock.synchronize {
+            @cache.delete(remote_id)
+            # log "=== removing remote ref #{id} -> #{remote_id}"
+            @queue.push(remote_id)
+          }
+        rescue ThreadError
+          # can't be called from trap contect - life is life ;)
+          # silently ignore
+        rescue
+          $!.print_stack_trace
+        end
+      }
+    end
+
+    # Create a reference correcting adapting remote types to ruby ecosystem, for example loads
+    # remote Java Set to a local ruby Set.
+    def create_reference reference_record
+      r = build_reference reference_record
+      case reference_record.className
+        when 'java.util.HashSet'
+          r.toArray()
+        else
+          r
+      end
+    end
+
+    # Create a reference from UMI remote object reference structure. Returns existing object if any. Takes care
+    # of dropping remote object when ruby object gets collected.
+    def build_reference reference_record
+      @lock.synchronize {
+        remote_id = reference_record.id
+        ref = @cache[remote_id]&.get
+        if !ref
+          # log "Creating new reference to remote #{remote_id}"
+          ref = Ref.new(self, reference_record)
+          ObjectSpace.define_finalizer(ref, create_finalizer(remote_id))
+          @cache[remote_id] = WeakReference.new(ref)
+        end
+        ref
+      }
+    end
+
+    # Start the remote object drop queue processing.
+    def start_cleanup_queue
+      return if @queue
+      @queue = Queue.new
+      @cleanup_thread = Thread.start {
+        while (!@closed)
+          id = @queue.pop()
+          if id == :poison_pill
+            # log "leaving cleanup queue"
+            break
+          else
+            begin
+              call("drop_objects", id)
+                # log "remote object dropped: #{id}"
+            rescue
+              $!.print_stack_trace
+            end
+          end
+        end
+      }
+    end
+
+    # convert ruby arguments array to corresponding UMI values
+    def prepare_args args
+      args.map {|x|
+        if x.respond_to?(:_as_umi_arg)
+          x._as_umi_arg(self)
+        else
+          case x
+            when String
+              x.encoding == Encoding::BINARY ? {__type: 'binary', base64: Base64.encode64(x)} : x
+            else
+              x
+          end
+        end
+      }
+    end
+
+    # Convert remote call result from UMI structures to ruby types
+    def encode_result value
+      case value
+        when Hashie::Mash
+          type = value.__type
+          case type
+            when 'RemoteObject';
+              create_reference value
+            when 'binary';
+              Base64.decode64(value.base64)
+            when 'unixtime';
+              Time.at(value.seconds)
+            else
+              value
+          end
+        when Hashie::Array
+          value.map {|x| encode_result x}
+        else
+          value
+      end
+    end
+
+    # @raise Error if interface is closed
+    def ensure_open
+      raise Error, "UMI interface is closed" if @closed
+    end
+
+    EMPTY_KWARGS = {}
+
+    # perform UMI remote call
+    def call(command, *args)
+      log ">> #{command}(#{args})"
+      result = @endpoint.sync_call(command, *args, **EMPTY_KWARGS)
+      log "<< #{result}"
+      result
+    end
+
+    def log msg
+      @trace and puts "UNIMI #{msg}"
+    end
+
+  end
+
+  ##
+  # A reference to any Java-object that can call its methods like usual methods:
+  #
+  #     key = umi.instantiate "PrivateKey", 2048 # this returns Ref
+  #     address = key.getPublicKey().getShortAddress().toString()
+  #
+  # Notice that all methods called after +key+ are java methods of +PrivateKey+, +PublicKey+ and +KeyAddress+
+  # Java classes, whose references are created on-the-fly automatically (and will be reclaimed by GC on both
+  # ends soon).
+  #
+  # == Instances are uniqie
+  #
+  # What means, if some calls will return the same Java object instance, it will be returned as the same {Ref}
+  # instance.
+  #
+  # == Reference equality (== and !=)
+  #
+  # References are equal if they refer the same objects OR their are +equals+ - the java.equals() is called
+  # to compare different referenced objects. Therefore, to compare two references use:
+  #
+  # - `==`: returns true if referencs are to the same object or different objects that where left.equals(right)
+  #         returns true.
+  # - `!=`: same as !(left == right)
+  # - `===`: thest that references refer to exactly same object instance. E.g. it is possible that
+  #          `left == right && !()left === right) - different objects which `equals()`.
+  #
+  # Reference lifespan
+  #
+  # Each {Ref} has an allocated object in the remote side which is retained until explicetly freed by the proper
+  # UMI call. {Ref} class rakes care of it: when the ruby +Ref+ instance is garbage collected, its remote counterpart
+  # will shortly receive drop command preventing memory leakage.
+  #
+  # == Arguments
+  #
+  # you can use basic ruby objects as arguments: strings, numbers, arrays, hashes, and {Ref} instances too. Note
+  # that:
+  #
+  # - binary string (Encoding::Binary) are converted to byte[] iin Java side
+  # - utf8 strings are passed as strings.
+  #
+  # == Return value
+  #
+  # Will be deep-converted to corresponding ruby objects: hashes, arrays, sets, numbers, strings and {Ref} instances
+  # as need. It is, generally, inverse of converting arguments covered above.
+  #
+  class Ref
+    # Create new reference. Do not call it directly: the {UMI} instance will do it in a correct order.
+    # @param [UMI] umi instance to bind to
+    # @param [Hash] ref UMI reference structure
+    def initialize(umi, ref)
+      @umi, @ref = umi, ref
+      @id = ref.id
+    end
+
+    # @return [UMI] interface that this reference is bound to (and created by)
+    def _umi
+      @umi
+    end
+
+    # @return [Object] remote object id. Could be of any type actually.
+    def _remote_id
+      @id
+    end
+
+    # Internal use only. Allow processing remote commands as local calls
+    def respond_to_missing?(method_name, include_private = false)
+      method_name[0] == '_' ? super : true
+    end
+
+    #Internal use only. Call remote method as needed. This is where all the magick comes from: it call remote method instead of the
+    # local one, exactly like it is local.
+    def method_missing(method_name, *args, &block)
+      if method_name[0] == '_'
+        super
+      else
+        @umi.invoke self, method_name, *args
+      end
+    end
+
+    # Internal use only. This allow Ref instance to be an argument to the remote call. Convert it to proper UMI structure.
+    def _as_umi_arg(umi)
+      umi == @umi or raise InterchangeError
+      @ref
+    end
+
+    # short data label for instance
+    def inspect
+      "<UMI:Ref:#{@umi.__id__}:#{@ref.className}:#{@id})>"
+    end
+
+    # Checks that references are euqal: either both point to the same remote object or respective remote objects
+    # are reported equals by the remote +equals()+ call.
+    def ==(other)
+      other.is_a?(Ref) && other._umi == @umi &&
+          (other._remote_id == @id || other.equals(self))
+    end
+
+    # Equal references. Both point to the same remote object. Note that it should never happen with {UMI} class
+    # as it do cache non-recycled references and share them between calls.
+    def ===(other)
+      other.is_a?(Ref) && other._umi == @umi && other._remote_id == @id
+    end
+
+  end
+
+end

data/lib/universa/version.rb

@@ -1,3 +1,4 @@
 module Universa
-  VERSION = "0.1.0"
+  # Current gem version
+  VERSION = "0.1.1"
 end

data/lib/universa/weak_reference.rb

@@ -0,0 +1,60 @@
+module Universa
+
+  # The smarter and safer weak reference than a standard one.
+  # It keeps object_id even if it is GC'd and can create a hard
+  # reference when possible. Some code borrowed from
+  # https://github.com/ruby-concurrency/ref.
+  #
+  # Note there is no +alive?+ method because it is not thread safe.
+  # Use the safe approach:
+  #
+  #     weak = WeakReference.new(something)
+  #     hard = weak.get
+  #     if hard
+  #        # we got safe reference in +hard+
+  #     end
+  #
+  # or, scala/kotlin-style:
+  #
+  #     weak.let { |object|
+  #       object.do_somethinf
+  #     }
+  #
+  class WeakReference
+
+    # ruby object it of the referenced object. Available also after object is recycled.
+    attr :referenced_object_id
+
+    # Create weak reference for a given object
+    def initialize(object)
+      @referenced_object_id = object.__id__
+      @weakref = WeakRef.new(object)
+    end
+
+    # Call the block passing it hard ref to the object if it is not yet recycled
+    #
+    # @return what the block returned or nil
+    # @yield object if it is not recycled
+    def let
+      if (hardref = object.get)
+        yield hardref
+      else
+        nil
+      end
+    end
+
+    # Get the strong reference unless it is already reclaimed.
+    #
+    # @return [Object] har reference to the source object or nil
+    def get
+      @weakref.__getobj__
+    rescue => e
+      # Jruby implementation uses RefError while MRI uses WeakRef::RefError
+      if (defined?(RefError) && e.is_a?(RefError)) || (defined?(::WeakRef::RefError) && e.is_a?(::WeakRef::RefError))
+        nil
+      else
+        raise e
+      end
+    end
+  end
+end

data/lib/universa.rb

@@ -1,5 +1,14 @@
 require "universa/version"
+require "universa/errors"
+require "universa/umi"
 
+# The Universa gem
+#
+# Currently, only direct access to the Java API is available:
+#
+# - class {UMI}. Use it to get direct access to the Java API
+#
+# Ruby-wrappers and tools are not yet available. Still direct access could be all you need at the time.
+#
 module Universa
-  # Your code goes here...
 end

data/universa.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.email         = ["real.sergeych@gmail.com"]
 
   spec.summary       = %q{Expose Universa Java API to ruby}
-  spec.description   = %q{Uses RPC Universa client}
+  spec.description   = %q{Uses UMI Universa client}
   # spec.homepage      = "TODO: Put your gem's website or public repo URL here."
   spec.license       = "MIT"
 
@@ -30,6 +30,8 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "farcall", ">= 0.4.6"
+
   spec.add_development_dependency "bundler", "~> 1.16"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.8"

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: universa
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - sergeych
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-10-31 00:00:00.000000000 Z
+date: 2018-11-01 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: farcall
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.6
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -52,7 +66,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.8'
-description: Uses RPC Universa client
+description: Uses UMI Universa client
 email:
 - real.sergeych@gmail.com
 executables:
@@ -69,10 +83,38 @@ files:
 - README.md
 - Rakefile
 - bin/console
+- bin/refresh_umi
 - bin/setup
+- bin/umi/bin/umi
+- bin/umi/bin/umi.bat
+- bin/umi/lib/com.fasterxml.jackson.core.jackson-annotations-2.8.11.jar
+- bin/umi/lib/com.fasterxml.jackson.core.jackson-core-2.8.11.jar
+- bin/umi/lib/com.fasterxml.jackson.core.jackson-databind-2.8.11.1.jar
+- bin/umi/lib/com.fasterxml.jackson.datatype.jackson-datatype-jdk8-2.8.11.jar
+- bin/umi/lib/com.fasterxml.jackson.datatype.jackson-datatype-jsr310-2.8.11.jar
+- bin/umi/lib/com.icodici.common_tools-3.8.3.jar
+- bin/umi/lib/com.icodici.crypto-3.8.3.jar
+- bin/umi/lib/com.icodici.nanohttpd-2.1.0.jar
+- bin/umi/lib/com.icodici.umi-0.8.7.jar
+- bin/umi/lib/com.icodici.universa_core-3.8.3.jar
+- bin/umi/lib/com.madgag.spongycastle.core-1.58.0.0.jar
+- bin/umi/lib/com.squareup.jnagmp.jnagmp-2.0.0.jar
+- bin/umi/lib/com.typesafe.play.play-functional_2.12-2.6.10.jar
+- bin/umi/lib/com.typesafe.play.play-json_2.12-2.6.10.jar
+- bin/umi/lib/net.java.dev.jna.jna-4.5.1.jar
+- bin/umi/lib/net.java.dev.jna.jna-platform-4.5.0.jar
+- bin/umi/lib/net.sf.jopt-simple.jopt-simple-4.9.jar
+- bin/umi/lib/org.scala-lang.scala-library-2.12.7.jar
+- bin/umi/lib/org.scala-lang.scala-reflect-2.12.7.jar
+- bin/umi/lib/org.scala-sbt.ipcsocket.ipcsocket-1.0.0.jar
+- bin/umi/lib/org.typelevel.macro-compat_2.12-1.1.1.jar
+- bin/umi/lib/org.yaml.snakeyaml-1.18.jar
 - exe/universa
 - lib/universa.rb
+- lib/universa/errors.rb
+- lib/universa/umi.rb
 - lib/universa/version.rb
+- lib/universa/weak_reference.rb
 - universa.gemspec
 homepage: 
 licenses: