javonet-nodejs-sdk 2.0.4 → 2.1.0

package/Binaries/Ruby/Linux/X64/core/interpreter/interpreter.rb

@@ -0,0 +1,30 @@
+require_relative '../protocol/command_serializer'
+require_relative '../protocol/command_deserializer'
+require_relative '../handler/handler'
+
+class Interpreter
+  def execute(command, connection_type, tcp_address)
+
+    command_serializer = CommandSerializer.new
+    message_byte_array = command_serializer.encode(command, connection_type, tcp_address)
+    if command.runtime_name == RuntimeName::RUBY
+      require_relative '../receiver/receiver'
+      response_byte_array = Receiver.new.send_command(message_byte_array, message_byte_array.length)
+    else
+      require_relative '../transmitter/transmitter'
+      response_byte_array = Transmitter.send_command(message_byte_array, message_byte_array.length)
+    end
+
+    command_deserializer = CommandDeserializer.new(response_byte_array,response_byte_array.length)
+    encoded_response = command_deserializer.decode
+    return encoded_response
+  end
+
+  def process(byte_array, byte_array_len)
+    command_deserializer = CommandDeserializer.new(byte_array,byte_array_len)
+    received_command = command_deserializer.decode
+    handler = Handler.new
+    command_serializer = CommandSerializer.new
+    return command_serializer.encode(handler.handle_command(received_command), 0, "0.0.0.0:0")
+  end
+end

package/Binaries/Ruby/Linux/X64/core/protocol/command_deserializer.rb

@@ -1,7 +1,7 @@
 require_relative 'type_deserializer'
-require_relative '../../sdk/core/type'
-require_relative '../../sdk/core/ruby_command'
-require_relative '../../sdk/core/string_encoding_mode'
+require_relative '../../utils/type'
+require_relative '../../utils/command'
+require_relative '../../utils/string_encoding_mode'
 
 class CommandDeserializer
 
@@ -9,7 +9,7 @@ class CommandDeserializer
     def initialize(buffer,byte_array_len)
         @buffer = buffer
         @byte_array_len = byte_array_len
-        @command = RubyCommand.new(buffer[0], buffer[10], [])
+        @command = Command.new(buffer[0], buffer[10], [])
         @position = 11
     end
 
@@ -58,7 +58,7 @@ class CommandDeserializer
         command_type = @buffer[p + 6]
 
         @position += 7
-        return_command = RubyCommand.new(runtime, command_type, [])
+        return_command = Command.new(runtime, command_type, [])
         return read_command_recursively(number_of_elements_in_payload, return_command)
     end
 
@@ -67,7 +67,6 @@ class CommandDeserializer
             return cmd
         else
             p = @position
-            arg_size = TypeDeserializer.deserialize_int(@buffer[p+1..p+4])
             new_command = cmd.add_arg_to_payload(self.read_object(@buffer[p]))
             return read_command_recursively(number_of_elements_in_payload_left - 1, new_command)
         end

package/Binaries/Ruby/Linux/X64/core/protocol/command_serializer.rb

@@ -1,6 +1,6 @@
 require_relative 'type_serializer'
-require_relative '../../sdk/internal/connection_type'
-require_relative '../../sdk/core/runtime_lib'
+require_relative '../../utils/connection_type'
+require_relative '../../utils/runtime_name'
 
 class CommandSerializer
 
@@ -9,10 +9,10 @@ class CommandSerializer
   end
 
 
-  def encode(root_command, connection_type, tcp_address = nil, runtimeVersion = 0)
+  def encode(root_command, connection_type = ConnectionType::IN_MEMORY, tcp_address = nil, runtimeVersion = 0)
     queue = []
     queue.unshift(root_command)
-    self.insert_into_buffer([root_command.runtime_lib, runtimeVersion])
+    self.insert_into_buffer([root_command.runtime_name, runtimeVersion])
     if connection_type == ConnectionType::TCP
       self.insert_into_buffer([ConnectionType::TCP])
       self.insert_into_buffer(self.serialize_tcp(tcp_address))
@@ -21,7 +21,7 @@ class CommandSerializer
       self.insert_into_buffer([ConnectionType::IN_MEMORY])
       self.insert_into_buffer([0, 0, 0, 0, 0, 0])
     end
-    self.insert_into_buffer([RuntimeLib::RUBY, root_command.command_type])
+    self.insert_into_buffer([RuntimeName::RUBY, root_command.command_type])
     return self.serialize_recursively(queue)
   end
 
@@ -58,7 +58,7 @@ class CommandSerializer
       serialized_bool = TypeSerializer.serialize_bool(payload_item)
       return serialized_bool
     else
-      return None
+      return nil
     end
   end
 
@@ -75,7 +75,7 @@ class CommandSerializer
     command = queue.shift
     queue.unshift(command.drop_first_payload_argument)
     if command.payload.length > 0
-      if command.payload[0].is_a? RubyCommand
+      if command.payload[0].is_a? Command
         inner_command = command.payload[0]
         self.insert_into_buffer(TypeSerializer.serialize_command(inner_command))
         queue.unshift(inner_command)

package/Binaries/Ruby/Linux/X64/core/protocol/type_deserializer.rb

@@ -1,4 +1,4 @@
-require_relative '../../sdk/core/string_encoding_mode'
+require_relative '../../utils/string_encoding_mode'
 
 class TypeDeserializer
 
@@ -67,7 +67,7 @@ class TypeDeserializer
   # end
 
   def self.deserialize_command(command_byte_array)
-    python_command = RubyCommand.new(RuntimeLib(command_byte_array[0]), RubyCommandType(command_byte_array[1]), [])
+    python_command = Command.new(RuntimeName(command_byte_array[0]), CommandType(command_byte_array[1]), [])
     return python_command
   end
 

package/Binaries/Ruby/Linux/X64/core/protocol/type_serializer.rb

@@ -1,5 +1,5 @@
-require_relative '../../sdk/core/type'
-require_relative '../../sdk/core/string_encoding_mode'
+require_relative '../../utils/type'
+require_relative '../../utils/string_encoding_mode'
 
 class TypeSerializer
 
@@ -62,7 +62,7 @@ class TypeSerializer
 
   def self.serialize_command(command)
       length = [command.payload.length()].pack("i").bytes
-      return [Type::COMMAND] + length + [command.runtime_lib, command.command_type]
+      return [Type::COMMAND] + length + [command.runtime_name, command.command_type]
   end
 
 end

package/Binaries/Ruby/Linux/X64/core/receiver/receiver.rb

@@ -1,16 +1,16 @@
-require_relative '../interpreter/ruby_interpreter'
+require_relative '../interpreter/interpreter'
 
 class Receiver
   
   def initialize
-    @@ruby_interpreter = RubyInterpreter.new
+    @@interpreter = Interpreter.new
   end
 
   def send_command(message_array, message_array_len)
-    return @@ruby_interpreter.process(message_array, message_array_len)
+    @@interpreter.process(message_array, message_array_len)
   end
   
   def heart_beat(message_array, message_array_len)
-    response_array = [49,48]
+    [49,48]
   end
 end

package/Binaries/Ruby/Linux/X64/core/transmitter/{ruby_transmitter.rb → transmitter.rb}

@@ -1,16 +1,16 @@
 require 'ffi'
 require 'os'
-require_relative 'ruby_transmitter_wrapper'
+require_relative 'transmitter_wrapper'
 
-class RubyTransmitter
+class Transmitter
 
   def self.send_command(messageArray, messageArrayLen)
     message = FFI::MemoryPointer.new(:uchar, messageArrayLen, true)
     message.put_array_of_uchar(0, messageArray)
-    responseArrayLen = RubyTransmitterWrapper.SendCommand(message, messageArrayLen)
+    responseArrayLen = TransmitterWrapper.SendCommand(message, messageArrayLen)
     if responseArrayLen >0
       response = FFI::MemoryPointer.new(:uchar, responseArrayLen, true)
-      RubyTransmitterWrapper.ReadResponse(response, responseArrayLen)
+      TransmitterWrapper.ReadResponse(response, responseArrayLen)
       responseArray = response.get_array_of_uchar(0, responseArrayLen)
       return responseArray
     else
@@ -31,7 +31,7 @@ class RubyTransmitter
   end
 
   private_class_method def self.activate(email="", licenceKey="", proxyHost="", proxyUserName="", proxyUserPassword="")
-    return RubyTransmitterWrapper.Activate(email, licenceKey, proxyHost, proxyUserName, proxyUserPassword)
+    return TransmitterWrapper.Activate(email, licenceKey, proxyHost, proxyUserName, proxyUserPassword)
   end
 
 end

package/Binaries/Ruby/{MacOs/X64/core/transmitter/ruby_transmitter_wrapper.rb → Linux/X64/core/transmitter/transmitter_wrapper.rb}

@@ -1,4 +1,4 @@
-module RubyTransmitterWrapper
+module TransmitterWrapper
   extend FFI::Library
     if OS.linux?
       ffi_lib File.expand_path('../../../Binaries/Native/Linux/X64/libJavonetRubyRuntimeNative.so', __FILE__)

package/Binaries/Ruby/Linux/X64/{sdk/core/ruby_command.rb → utils/command.rb}

@@ -1,15 +1,15 @@
-require_relative 'runtime_lib'
-require_relative 'ruby_command_type'
+require_relative 'runtime_name'
+require_relative 'command_type'
 
-class RubyCommand
-  def initialize(runtime_lib, command_type, payload)
-    @runtime_lib = runtime_lib
+class Command
+  def initialize(runtime_name, command_type, payload)
+    @runtime_name = runtime_name
     @command_type = command_type
     @payload = payload
   end
 
-  def runtime_lib
-    @runtime_lib
+  def runtime_name
+    @runtime_name
   end
 
   def command_type
@@ -21,7 +21,7 @@ class RubyCommand
   end
 
   def to_string
-    'Runtime Library: ' + RuntimeLib.get_name(@runtime_lib).to_s + ' ' + 'Ruby command type: ' + RubyCommandType.get_name(@command_type).to_s + ' ' + 'with parameters: ' + @payload.to_s
+    'Runtime Library: ' + RuntimeName.get_name(@runtime_name).to_s + ' ' + 'Ruby command type: ' + CommandType.get_name(@command_type).to_s + ' ' + 'with parameters: ' + @payload.to_s
   end
 
   def eql?(other)
@@ -32,7 +32,7 @@ class RubyCommand
     if other == nil or self.class != other.class
       @is_equal = false
     end
-    if self.command_type == other.command_type and self.runtime_lib == other.runtime_lib
+    if self.command_type == other.command_type and self.runtime_name == other.runtime_name
       @is_equal = true
     end
     if payload.length == other.payload.length
@@ -54,15 +54,15 @@ class RubyCommand
   end
 
   def create_response(response)
-    return RubyCommand.new(@runtime_lib, RubyCommandType::RESPONSE, [response])
+    return Command.new(@runtime_name, CommandType::VALUE, [response])
   end
 
   def create_reference(guid)
-    return RubyCommand.new(@runtime_lib, RubyCommandType::REFERENCE, [guid])
+    return Command.new(@runtime_name, CommandType::REFERENCE, [guid])
   end
 
   def create_array_response(array)
-    return RubyCommand.new(@runtime_lib, RubyCommandType::ARRAY, [array])
+    return Command.new(@runtime_name, CommandType::ARRAY, [array])
   end
 
   def drop_first_payload_argument
@@ -71,17 +71,21 @@ class RubyCommand
     if payload_args.length != 0
       payload_args.delete_at(0)
     end
-    return RubyCommand.new(@runtime_lib, @command_type, payload_args)
+    return Command.new(@runtime_name, @command_type, payload_args)
   end
 
   def add_arg_to_payload(argument)
     merged_payload = payload + [argument]
-    return RubyCommand.new(@runtime_lib, @command_type, merged_payload)
+    return Command.new(@runtime_name, @command_type, merged_payload)
   end
 
-  def add_arg_to_payload_on_beginning(argument)
-    merged_payload = [argument] + payload
-    return RubyCommand.new(@runtime_lib, @command_type, merged_payload)
+  def add_arg_to_payload_on_beginning(current_command)
+    if current_command.nil?
+      return Command.new(@runtime_name, @command_type, @payload)
+    else
+      merged_payload = [current_command] + payload
+      return Command.new(@runtime_name, @command_type, merged_payload)
+    end
   end
 
 end

package/Binaries/Ruby/Linux/X64/{sdk/core/ruby_command_type.rb → utils/command_type.rb}

@@ -1,5 +1,5 @@
-class RubyCommandType
-  RESPONSE = 0
+class CommandType
+  VALUE = 0
   LOAD_LIBRARY = 1
   INVOKE_STATIC_METHOD = 2
   GET_STATIC_FIELD = 3
@@ -18,65 +18,59 @@ class RubyCommandType
   INVOKE_GLOBAL_METHOD = 16
   DESTRUCT_REFERENCE = 17
   ARRAY = 18
-
+  ARRAY_GET_ITEM = 19
+  ARRAY_GET_SIZE = 20
+  ARRAY_GET_RANK = 21
+  ARRAY_SET_ITEM = 22
 
   def self.get_name(command_number)
-    if command_number == 0
-      return 'RESPONSE'
-    end
-    if command_number == 1
+    case command_number
+    when 0
+      return 'VALUE'
+    when 1
       return 'LOAD_LIBRARY'
-    end
-    if command_number == 2
+    when 2
       return 'INVOKE_STATIC_METHOD'
-    end
-    if command_number == 3
+    when 3
       return 'GET_STATIC_FIELD'
-    end
-    if command_number == 4
+    when 4
       return 'SET_STATIC_FIELD'
-    end
-    if command_number == 5
+    when 5
       return 'CREATE_CLASS_INSTANCE'
-    end
-    if command_number == 6
+    when 6
       return 'GET_TYPE'
-    end
-    if command_number == 7
+    when 7
       return 'REFERENCE'
-    end
-    if command_number == 8
+    when 8
       return 'GET_MODULE'
-    end
-    if command_number == 9
+    when 9
       return 'INVOKE_INSTANCE_METHOD'
-    end
-    if command_number == 10
+    when 10
       return 'EXCEPTION'
-    end
-    if command_number == 11
+    when 11
       return 'HEART_BEAT'
-    end
-    if command_number == 12
+    when 12
       return 'CAST'
-    end
-    if command_number == 13
+    when 13
       return 'GET_INSTANCE_FIELD'
-    end
-    if command_number == 14
+    when 14
       return 'OPTIMIZE'
-    end
-    if command_number == 15
+    when 15
       return 'GENERATE_LIB'
-    end
-    if command_number == 16
+    when 16
       return 'INVOKE_GLOBAL_METHOD'
-    end
-    if command_number == 17
+    when 17
       return 'DESTRUCT_REFERENCE'
-    end
-    if command_number == 18
+    when 18
       return 'ARRAY'
+    when 19
+      return 'ARRAY_GET_ITEM'
+    when 20
+      return 'ARRAY_GET_SIZE'
+    when 21
+      return 'ARRAY_GET_RANK'
+    when 22
+      return 'ARRAY_SET_ITEM'
     end
   end
 end

package/Binaries/Ruby/Linux/X64/{sdk/core → utils}/explicit_cast.rb

@@ -1,13 +1,13 @@
 class ExplicitCast
   def cast(value, target_type)
-    RubyCommand.new(
+    Command.new(
       100,
-      RubyCommandType::CAST,
+      CommandType::CAST,
       [
         value,
-        RubyCommand.new(
+        Command.new(
           100,
-          RubyCommandType::GET_TYPE,
+          CommandType::GET_TYPE,
           target_type
         )
       ]

package/Binaries/Ruby/{MacOs/X64/sdk/core/runtime_lib.rb → Linux/X64/utils/runtime_name.rb}

@@ -1,4 +1,4 @@
-module RuntimeLib
+module RuntimeName
   CLR = 0
   GO = 1
   JVM = 2

package/Binaries/Ruby/MacOs/X64/core/exceptions/exception_serializer.rb

@@ -0,0 +1,94 @@
+require_relative '../exceptions/exception_type'
+
+
+class ExceptionSerializer
+
+  def self.serialize_exception(exception, command)
+    exception_command = Command.new(RuntimeName::RUBY, CommandType::EXCEPTION, [])
+
+    stack_trace = exception.backtrace
+    exception_message = exception.message
+    exception_name = exception.class
+    stack_classes = ""
+    stack_methods = ""
+    stack_lines = ""
+    stack_files = ""
+    stack_trace.each_with_index do |value, index|
+      stack_file, stack_class, stack_line, stack_method = parse_stack_frame(value)
+      append_to_string(stack_classes, stack_class)
+      append_to_string(stack_methods, stack_method)
+      append_to_string(stack_lines, stack_line)
+      append_to_string(stack_files, stack_file)
+
+      if index != stack_trace.length() - 1
+        append_to_string(stack_classes, "|")
+        append_to_string(stack_methods, "|")
+        append_to_string(stack_lines, "|")
+        append_to_string(stack_files, "|")
+      end
+
+
+    end
+
+    exception_command = exception_command.add_arg_to_payload(get_exception_code(exception_name.to_s))
+    exception_command = exception_command.add_arg_to_payload(command.to_string)
+    exception_command = exception_command.add_arg_to_payload(exception_name.to_s)
+    exception_command = exception_command.add_arg_to_payload(exception_message)
+    exception_command = exception_command.add_arg_to_payload(stack_classes)
+    exception_command = exception_command.add_arg_to_payload(stack_methods)
+    exception_command = exception_command.add_arg_to_payload(stack_lines)
+    exception_command = exception_command.add_arg_to_payload(stack_files)
+
+    return exception_command
+  end
+
+  def self.append_to_string(string,value)
+    if value.nil?
+      string << "undefined"
+    else
+      string << value
+    end
+  end
+
+  def self.parse_stack_frame(stack_frame)
+    # Extract the file path, line number, and method name using regular expressions
+    match = /(.+):(\d+):in `(.+)'/.match(stack_frame)
+
+    # Extract the name of the file without the full path
+    file_name = File.basename(match[1])
+
+    # Extract the class name and method name
+    method_name = match[3]
+    class_name = nil
+    if method_name =~ /(.+)#(.+)/
+      class_name = $1.split('::')[-1]
+      method_name = $2
+    end
+
+    # Return the four variables as an array
+    [match[1], class_name, match[2], method_name]
+  end
+
+  def self.get_exception_code(exception_name)
+    case exception_name
+    when "Exception"
+      return ExceptionType::EXCEPTION
+    when "IOError"
+      return ExceptionType::IO_EXCEPTION
+    when "Errno::ENOENT"
+      return ExceptionType::FILE_NOT_FOUND_EXCEPTION
+    when "RuntimeError"
+      return ExceptionType::RUNTIME_EXCEPTION
+    when "ZeroDivisionError"
+      return ExceptionType::ARITHMETIC_EXCEPTION
+    when "ArgumentError"
+      return ExceptionType::ILLEGAL_ARGUMENT_EXCEPTION
+    when "IndexError"
+      return ExceptionType::INDEX_OUT_OF_BOUNDS_EXCEPTION
+    when "TypeError"
+      return ExceptionType::NULL_POINTER_EXCEPTION
+    else
+      return exception_name
+    end
+  end
+end

package/Binaries/Ruby/MacOs/X64/core/exceptions/exception_thrower.rb

@@ -0,0 +1,54 @@
+require_relative '../exceptions/exception_type'
+
+class ExceptionThrower
+
+  def self.throw_exception(exception_command)
+    exception_code = exception_command.payload[0]
+    javonet_stack_command = exception_command.payload[1]
+    exception_name =  exception_command.payload[2]
+    exception_message = exception_command.payload[3]
+
+    exception_object = get_exception_object(exception_code, exception_message)
+
+    stack_trace = get_local_stack_trace(exception_command.payload[4], exception_command.payload[5], exception_command.payload[6], exception_command.payload[7])
+    exception_object.set_backtrace(stack_trace)
+    raise exception_object
+
+  end
+
+  def self.get_local_stack_trace(stack_trace_classes, stack_trace_methods, stack_trace_lines, stack_trace_files)
+    stack_classes_array = stack_trace_classes.split("|")
+    stack_methods_array = stack_trace_methods.split("|")
+    stack_lines_array = stack_trace_lines.split("|")
+    stack_files_array = stack_trace_files.split("|")
+
+    stack_trace = []
+    stack_classes_array.each_with_index do |class_name, index|
+      stack_trace << "#{stack_files_array[index]}:#{stack_lines_array[index]}:in `#{class_name}##{stack_methods_array[index]}'"
+    end
+    return stack_trace
+  end
+
+  def self.get_exception_object(exception_code, exception_message)
+    case exception_code
+    when ExceptionType::EXCEPTION
+      return Exception.new("Exception " + exception_message)
+    when ExceptionType::IO_EXCEPTION
+      return IOError.new("IOError " + exception_message)
+    when ExceptionType::FILE_NOT_FOUND_EXCEPTION
+      return Errno::ENOENT.new("Errno::ENOENT " + exception_message)
+    when ExceptionType::RUNTIME_EXCEPTION
+      return RuntimeError.new("RuntimeError " + exception_message)
+    when ExceptionType::ARITHMETIC_EXCEPTION
+      return ZeroDivisionError.new("ZeroDivisionError " + exception_message)
+    when ExceptionType::ILLEGAL_ARGUMENT_EXCEPTION
+      return ArgumentError.new("ArgumentError " + exception_message)
+    when ExceptionType::INDEX_OUT_OF_BOUNDS_EXCEPTION
+      return IndexError.new("IndexError " + exception_message)
+    when ExceptionType::NULL_POINTER_EXCEPTION
+      return TypeError.new("TypeError " + exception_message)
+    else
+      return Exception.new(exception_code.to_s + " " +exception_message)
+    end
+  end
+end

package/Binaries/Ruby/MacOs/X64/core/exceptions/exception_type.rb

@@ -0,0 +1,10 @@
+class ExceptionType
+  EXCEPTION = 0
+  IO_EXCEPTION = 1
+  FILE_NOT_FOUND_EXCEPTION = 2
+  RUNTIME_EXCEPTION = 3
+  ARITHMETIC_EXCEPTION = 4
+  ILLEGAL_ARGUMENT_EXCEPTION = 5
+  INDEX_OUT_OF_BOUNDS_EXCEPTION = 6
+  NULL_POINTER_EXCEPTION = 7
+end

package/Binaries/Ruby/MacOs/X64/core/handler/command_handler/abstract_command_handler.rb

@@ -4,19 +4,19 @@ class AbstractCommandHandler
 
   @required_parameters_count = 0
 
-  def handle_command(ruby_command)
-      iterate(ruby_command)
-      return process(ruby_command)
+  def handle_command(command)
+      iterate(command)
+      return process(command)
   end
 
   def iterate(command)
       (0..command.payload.length).step(1) do |i|
-        if command.payload[i].is_a? RubyCommand
+        if command.payload[i].is_a? Command
             command.payload[i] = $handler_dict[command.payload[i].command_type].handle_command(command.payload[i])
         end
       end
   end
-  def process(ruby_command)
+  def process(command)
     raise 'process is not implemented'
   end
 

package/Binaries/Ruby/MacOs/X64/core/handler/command_handler/array_get_item_handler.rb

@@ -0,0 +1,9 @@
+require_relative 'abstract_command_handler'
+
+class ArrayGetItemHandler < AbstractCommandHandler
+  def process(command)
+    array = command.payload[0]
+    index = command.payload[1,]
+    return array[index]
+  end
+end

package/Binaries/Ruby/MacOs/X64/core/handler/command_handler/array_get_rank_handler.rb

@@ -0,0 +1,7 @@
+require_relative 'abstract_command_handler'
+
+class ArrayGetRankHandler < AbstractCommandHandler
+  def process(command)
+    raise "ArrayGetRankHandler not implemented"
+  end
+end

package/Binaries/Ruby/MacOs/X64/core/handler/command_handler/array_get_size_handler.rb

@@ -0,0 +1,8 @@
+require_relative 'abstract_command_handler'
+
+class ArrayGetSizeHandler < AbstractCommandHandler
+  def process(command)
+    array = command.payload[0]
+    return array.length()
+  end
+end

package/Binaries/Ruby/MacOs/X64/core/handler/command_handler/array_set_item_handler.rb

@@ -0,0 +1,11 @@
+require_relative 'abstract_command_handler'
+
+class ArraySetItemHandler < AbstractCommandHandler
+  def process(command)
+    array = command.payload[0]
+    value = command.payload[1]
+    index = command.payload[2,]
+    array[index] = value
+    return 0
+  end
+end

package/Binaries/Ruby/MacOs/X64/core/handler/command_handler/casting_handler.rb

@@ -1,7 +1,7 @@
 require_relative 'abstract_command_handler'
 
 class CastingHandler < AbstractCommandHandler
-  def process(ruby_command)
+  def process(command)
     raise "Explicit cast is forbidden in dynamically typed languages"
   end
 end