javonet-ruby-sdk 2.0.4 → 2.1.1

data/lib/javonet-ruby-sdk/Binaries/Python/Windows/X64/javonet/core/protocol/CommandDeserializer.py

@@ -1,9 +1,9 @@
 from javonet.core.protocol.TypeDeserializer import TypeDeserializer
-from javonet.sdk.core.PythonCommand import PythonCommand
-from javonet.sdk.core.PythonCommandType import PythonCommandType
-from javonet.sdk.core.RuntimeLib import RuntimeLib
-from javonet.sdk.core.Type import Type
-from javonet.sdk.core.StringEncodingMode import StringEncodingMode
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
+from javonet.utils.RuntimeName import RuntimeName
+from javonet.utils.Type import Type
+from javonet.utils.StringEncodingMode import StringEncodingMode
 
 
 class CommandDeserializer:
@@ -15,7 +15,7 @@ class CommandDeserializer:
     def __init__(self, buffer, buffer_len):
         self.buffer = buffer
         self.buffer_len = buffer_len
-        self.command = PythonCommand(RuntimeLib(buffer[0]), PythonCommandType(buffer[10]), [])
+        self.command = Command(RuntimeName(buffer[0]), CommandType(buffer[10]), [])
         self.position = 11
 
     def is_at_end(self):
@@ -57,7 +57,7 @@ class CommandDeserializer:
         command_type = self.buffer[p + 6]
 
         self.position += 7
-        return_command = PythonCommand(RuntimeLib(runtime), PythonCommandType(command_type), [])
+        return_command = Command(RuntimeName(runtime), CommandType(command_type), [])
         return self.read_command_recursively(number_of_elements_in_payload, return_command)
 
     def read_command_recursively(self, number_of_elements_in_payload_left, cmd):

data/lib/javonet-ruby-sdk/Binaries/Python/Windows/X64/javonet/core/protocol/CommandSerializer.py

@@ -3,25 +3,25 @@ from collections import deque
 from typing import Deque
 
 from javonet.core.protocol.TypeSerializer import TypeSerializer
-from javonet.sdk.core.PythonCommand import PythonCommand
-from javonet.sdk.internal.ConnectionType import ConnectionType
-from javonet.sdk.core.RuntimeLib import RuntimeLib
+from javonet.utils.Command import Command
+from javonet.utils.ConnectionType import ConnectionType
+from javonet.utils.RuntimeName import RuntimeName
 
 
 class CommandSerializer:
     byte_buffer = []
 
     def encode(self, root_command, connection_type, tcp_address=None, runtime_version=0):
-        queue: Deque[PythonCommand] = deque()
+        queue: Deque[Command] = deque()
         queue.append(root_command)
-        self.insert_into_buffer([root_command.target_runtime.value, runtime_version])
+        self.insert_into_buffer([root_command.runtime_name.value, runtime_version])
         if connection_type == ConnectionType.Tcp.value:
             self.insert_into_buffer([ConnectionType.Tcp.value])
             self.insert_into_buffer(self.serialize_tcp(tcp_address))
         else:
             self.insert_into_buffer([ConnectionType.InMemory.value])
             self.insert_into_buffer(self.serialize_tcp("0.0.0.0:0"))
-        self.insert_into_buffer([RuntimeLib.python.value, root_command.command_type.value])
+        self.insert_into_buffer([RuntimeName.python.value, root_command.command_type.value])
         return self.serialize_recursively(queue)
 
     @staticmethod
@@ -64,7 +64,7 @@ class CommandSerializer:
         command = queue.pop()
         queue.append(command.drop_first_payload_argument())
         if len(command.get_payload()) > 0:
-            if isinstance(command.get_payload()[0], PythonCommand):
+            if isinstance(command.get_payload()[0], Command):
                 inner_command = command.get_payload()[0]
                 self.insert_into_buffer(TypeSerializer.serialize_command(inner_command))
                 queue.append(inner_command)

data/lib/javonet-ruby-sdk/Binaries/Python/Windows/X64/javonet/core/protocol/TypeDeserializer.py

@@ -1,9 +1,7 @@
 import struct
 
-from javonet.sdk.core import PythonCommand
-from javonet.sdk.core import PythonCommandType
-from javonet.sdk.core import RuntimeLib
-from javonet.sdk.core.StringEncodingMode import StringEncodingMode
+from javonet.utils import Command, CommandType, RuntimeName
+from javonet.utils.StringEncodingMode import StringEncodingMode
 
 
 class TypeDeserializer:
@@ -74,5 +72,5 @@ class TypeDeserializer:
 
     @staticmethod
     def deserialize_command(command_byte_array):
-        python_command = PythonCommand(RuntimeLib(command_byte_array[0]), PythonCommandType(command_byte_array[1]), [])
-        return python_command
+        command = Command(RuntimeName(command_byte_array[0]), CommandType(command_byte_array[1]), [])
+        return command

data/lib/javonet-ruby-sdk/Binaries/Python/Windows/X64/javonet/core/protocol/TypeSerializer.py

@@ -1,7 +1,7 @@
 import struct
 
-from javonet.sdk.core.Type import Type
-from javonet.sdk.core.StringEncodingMode import StringEncodingMode
+from javonet.utils.Type import Type
+from javonet.utils.StringEncodingMode import StringEncodingMode
 
 
 class TypeSerializer:
@@ -71,6 +71,6 @@ class TypeSerializer:
         return [Type.JavonetBytes.value, length] + encoded_bytes_list
 
     @staticmethod
-    def serialize_command(python_command):
-        length = list(bytearray(struct.pack("<i", len(python_command.payload))))
-        return [Type.Command.value] + length + [python_command.target_runtime.value, python_command.command_type.value]
+    def serialize_command(command):
+        length = list(bytearray(struct.pack("<i", len(command.payload))))
+        return [Type.Command.value] + length + [command.runtime_name.value, command.command_type.value]

data/lib/javonet-ruby-sdk/Binaries/Python/Windows/X64/javonet/core/receiver/Receiver.py

@@ -1,10 +1,10 @@
-from javonet.core.interpreter.PythonInterpreter import PythonInterpreter
+from javonet.core.interpreter.Interpreter import Interpreter
 
 
 class Receiver:
 
     def __init__(self):
-        self.python_interpreter = PythonInterpreter()
+        self.python_interpreter = Interpreter()
 
     def SendCommand(self, messageByteArray, messageByteArrayLen):
         return bytearray(self.python_interpreter.process(messageByteArray, len(messageByteArray)))

data/lib/javonet-ruby-sdk/Binaries/Python/Windows/X64/javonet/core/transmitter/PythonTransmitterWrapper.py

@@ -35,8 +35,16 @@ class PythonTransmitterWrapper:
             PythonTransmitterWrapper.python_lib.ReadResponse(response_ubyte_array.from_buffer(response),
                                                              response_array_len)
             return response
+        elif response_array_len == 0:
+            error_message = "Response is empty"
+            raise RuntimeError(error_message)
         else:
-            raise RuntimeError("Javonet native code error: " + str(response_array_len))
+            get_native_error = PythonTransmitterWrapper.python_lib.GetNativeError
+            get_native_error.restype = c_char_p
+            get_native_error.argtypes = []
+            error_message = get_native_error()
+            raise RuntimeError(
+                "Javonet native error code: " + str(response_array_len) + ". " + str(error_message))
 
     @staticmethod
     def activate(email, licence_key, proxy_host, proxy_user_name, proxy_user_password):
@@ -44,8 +52,19 @@ class PythonTransmitterWrapper:
         activate.restype = c_int
         activate.argtypes = [c_char_p, c_char_p, c_char_p, c_char_p, c_char_p]
 
-        return activate(email.encode('ascii'),
-                        licence_key.encode('ascii'),
-                        proxy_host.encode('ascii'),
-                        proxy_user_name.encode('ascii'),
-                        proxy_user_password.encode('ascii'))
+        activation_result = activate(email.encode('ascii'),
+                                     licence_key.encode('ascii'),
+                                     proxy_host.encode('ascii'),
+                                     proxy_user_name.encode('ascii'),
+                                     proxy_user_password.encode('ascii'))
+
+        if activation_result < 0:
+            get_native_error = PythonTransmitterWrapper.python_lib.GetNativeError
+            get_native_error.restype = c_char_p
+            get_native_error.argtypes = []
+            error_message = get_native_error()
+            raise RuntimeError(
+                "Javonet activation result: " + str(activation_result) + ". Native error message: " + str(error_message))
+        else:
+            return activation_result
+        

data/lib/javonet-ruby-sdk/Binaries/Python/Windows/X64/javonet/utils/Command.py

@@ -0,0 +1,67 @@
+from javonet.utils.CommandType import CommandType
+
+
+class Command:
+
+    def __init__(self, runtime_name, command_type, payload):
+        self.runtime_name = runtime_name
+        self.command_type = command_type
+        self.payload = payload
+
+    def get_payload(self):
+        return self.payload
+
+    @staticmethod
+    def create_response(response, runtime_name):
+        return Command(runtime_name, CommandType.Value, [response])
+
+    @staticmethod
+    def create_reference(guid, runtime_name):
+        return Command(runtime_name, CommandType.Reference, [guid])
+
+    @staticmethod
+    def create_array_response(array, runtime_name):
+        return Command(runtime_name, CommandType.Array, [array])
+
+    def drop_first_payload_argument(self):
+        payload_args = []
+        payload_args.extend(self.payload)
+        if len(payload_args) != 0:
+            payload_args.pop(0)
+        return Command(self.runtime_name, self.command_type, payload_args)
+
+    def add_arg_to_payload(self, argument):
+        merged_payload = self.payload + [argument]
+        return Command(self.runtime_name, self.command_type, merged_payload)
+
+    def append_arg_to_payload(self, current_command):
+        if current_command is None:
+            return Command(self.runtime_name, self.command_type, self.payload)
+        else:
+            return Command(self.runtime_name, self.command_type, [current_command] + self.payload)
+
+    def to_string(self):
+        return 'Target runtime: ' + str(self.runtime_name) + ' Command type: ' + str(
+            self.command_type) + ' Payload: ' + str(self.payload)
+
+    def __eq__(self, element):
+        self.is_equal = False
+        if self is element:
+            self.is_equal = True
+        if element is None or self.__class__ != element.__class__:
+            self.is_equal = False
+        if self.command_type is element.command_type and self.runtime_name is element.runtime_name:
+            self.is_equal = True
+        if len(self.payload) == len(element.payload):
+            i = 0
+            array_item_equal = False
+            for payload_item in self.payload:
+                if payload_item.__eq__(element.payload[i]):
+                    array_item_equal = True
+                else:
+                    array_item_equal = False
+                i += 1
+            self.is_equal = array_item_equal
+        else:
+            self.is_equal = False
+        return self.is_equal

data/lib/javonet-ruby-sdk/Binaries/Python/{MacOs/X64/javonet/sdk/core/PythonCommandType.py → Windows/X64/javonet/utils/CommandType.py}

@@ -1,23 +1,27 @@
-from enum import Enum
-
-
-class PythonCommandType(Enum):
-    Response = 0
-    LoadLibrary = 1
-    InvokeStaticMethod = 2
-    GetStaticField = 3
-    SetStaticField = 4
-    CreateClassInstance = 5
-    GetType = 6
-    Reference = 7
-    GetModule = 8
-    InvokeInstanceMethod = 9
-    Exception = 10
-    HeartBeat = 11
-    Cast = 12
-    GetInstanceField = 13
-    Optimize = 14
-    GenerateLib = 15
-    InvokeGlobalMethod = 16
-    DestructReference = 17
-    Array = 18
+from enum import Enum
+
+
+class CommandType(Enum):
+    Value = 0
+    LoadLibrary = 1
+    InvokeStaticMethod = 2
+    GetStaticField = 3
+    SetStaticField = 4
+    CreateClassInstance = 5
+    GetType = 6
+    Reference = 7
+    GetModule = 8
+    InvokeInstanceMethod = 9
+    Exception = 10
+    HeartBeat = 11
+    Cast = 12
+    GetInstanceField = 13
+    Optimize = 14
+    GenerateLib = 15
+    InvokeGlobalMethod = 16
+    DestructReference = 17
+    Array = 18
+    ArrayGetItem = 19
+    ArrayGetSize = 20
+    ArrayGetRank = 21
+    ArraySetItem = 22

data/lib/javonet-ruby-sdk/Binaries/Python/Windows/X64/javonet/utils/ExplicitCast.py

@@ -0,0 +1,21 @@
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
+
+
+class ExplicitCast:
+    @staticmethod
+    def cast(value, target_type):
+        return Command(
+            100,
+            CommandType.Cast,
+            [
+                value,
+                Command(
+                    100,
+                    CommandType.GetType,
+                    [
+                        target_type
+                    ]
+                )
+            ]
+        )

data/lib/javonet-ruby-sdk/Binaries/Python/Windows/X64/javonet/{sdk/core/RuntimeLib.py → utils/RuntimeName.py}

@@ -1,7 +1,7 @@
 from enum import Enum
 
 
-class RuntimeLib(Enum):
+class RuntimeName(Enum):
     clr = 0
     go = 1
     jvm = 2

data/lib/javonet-ruby-sdk/Binaries/Ruby/Linux/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)
+      if !stack_file.include?("javonet-ruby-sdk")
+        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
+    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]
+    file_name = File.basename(match[1], ".rb")
+    class_name = file_name.split('_').map(&:capitalize).join('')
+    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

data/lib/javonet-ruby-sdk/Binaries/Ruby/Linux/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

data/lib/javonet-ruby-sdk/Binaries/Ruby/Linux/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

data/lib/javonet-ruby-sdk/Binaries/Ruby/Linux/X64/core/handler/command_handler/abstract_command_handler.rb

@@ -4,19 +4,20 @@ 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
-            command.payload[i] = $handler_dict[command.payload[i].command_type].handle_command(command.payload[i])
-        end
+    (0..command.payload.length).step(1) do |i|
+      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
 

data/lib/javonet-ruby-sdk/Binaries/Ruby/Linux/X64/core/handler/command_handler/array_get_item_handler.rb

@@ -0,0 +1,13 @@
+require_relative 'abstract_command_handler'
+
+class ArrayGetItemHandler < AbstractCommandHandler
+  def process(command)
+    begin
+      array = command.payload[0]
+      index = command.payload[1,]
+      return array[index]
+    rescue Exception => e
+      return e
+    end
+  end
+end

data/lib/javonet-ruby-sdk/Binaries/Ruby/Linux/X64/core/handler/command_handler/array_get_rank_handler.rb

@@ -0,0 +1,11 @@
+require_relative 'abstract_command_handler'
+
+class ArrayGetRankHandler < AbstractCommandHandler
+  def process(command)
+    begin
+      raise "ArrayGetRankHandler not implemented"
+    rescue Exception => e
+      return e
+    end
+  end
+end

data/lib/javonet-ruby-sdk/Binaries/Ruby/Linux/X64/core/handler/command_handler/array_get_size_handler.rb

@@ -0,0 +1,12 @@
+require_relative 'abstract_command_handler'
+
+class ArrayGetSizeHandler < AbstractCommandHandler
+  def process(command)
+    begin
+      array = command.payload[0]
+      return array.length()
+    rescue Exception => e
+      return e
+    end
+  end
+end

data/lib/javonet-ruby-sdk/Binaries/Ruby/Linux/X64/core/handler/command_handler/array_set_item_handler.rb

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

data/lib/javonet-ruby-sdk/Binaries/Ruby/Linux/X64/core/handler/command_handler/casting_handler.rb

@@ -1,7 +1,11 @@
 require_relative 'abstract_command_handler'
 
 class CastingHandler < AbstractCommandHandler
-  def process(ruby_command)
-    raise "Explicit cast is forbidden in dynamically typed languages"
+  def process(command)
+    begin
+      raise "Explicit cast is forbidden in dynamically typed languages"
+    rescue Exception => e
+      return e
+    end
   end
 end