javonet-ruby-sdk 2.6.0 → 2.6.2

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/protocol/CommandDeserializer.py

@@ -7,8 +7,8 @@ from javonet.core.protocol.TypeDeserializer import TypeDeserializer
 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
+from javonet.utils.Type import Type
 
 
 class CommandDeserializer(object):
@@ -28,6 +28,8 @@ class CommandDeserializer(object):
         """
         self.buffer = buffer
         self.buffer_len = len(buffer)
+        if self.buffer_len < 11:
+            raise ValueError("Buffer too small to contain a command header.")
         self.command = Command(RuntimeName(buffer[0]), CommandType(buffer[10]), [])
         self.position = 11
 
@@ -37,7 +39,7 @@ class CommandDeserializer(object):
 
         :return: True if end of buffer is reached, False otherwise
         """
-        return self.position == self.buffer_len
+        return self.position >= self.buffer_len
 
     def deserialize(self):
         """
@@ -49,6 +51,11 @@ class CommandDeserializer(object):
             self.command = self.command.add_arg_to_payload(self.read_object(self.buffer[self.position]))
         return self.command
 
+    def _check_buffer(self, required_size):
+        """Checks if there are enough bytes left in the buffer."""
+        if self.position + required_size > self.buffer_len:
+            raise IndexError("Not enough data in buffer to read next value.")
+
     def read_object(self, type_num):
         """
         Reads an object from the buffer based on its type.
@@ -71,7 +78,10 @@ class CommandDeserializer(object):
             Type.JavonetUnsignedInteger: self.read_uint,
             Type.JavonetNoneType: self.read_none
         }
-        return switch.get(type_value, lambda: Exception("Type not supported"))()
+        func = switch.get(type_value)
+        if func is None:
+            raise ValueError("Type not supported: " + str(type_num))
+        return func()
 
     def read_command(self):
         """
@@ -79,28 +89,18 @@ class CommandDeserializer(object):
 
         :return: Read command
         """
+        self._check_buffer(7)
         p = self.position
         number_of_elements_in_payload = TypeDeserializer.deserialize_int(self.buffer[p + 1: p + 5])
         runtime = self.buffer[p + 5]
         command_type = self.buffer[p + 6]
         self.position += 7
-        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):
-        """
-        Recursively reads a command from the buffer.
+        payload = []
+        for _ in xrange(number_of_elements_in_payload):
+            payload.append(self.read_object(self.buffer[self.position]))
 
-        :param number_of_elements_in_payload_left: Number of elements left to read
-        :param cmd: Command to populate
-        :return: Populated command
-        """
-        if number_of_elements_in_payload_left == 0:
-            return cmd
-        else:
-            p = self.position
-            cmd = cmd.add_arg_to_payload(self.read_object(self.buffer[p]))
-            return self.read_command_recursively(number_of_elements_in_payload_left - 1, cmd)
+        return Command(RuntimeName(runtime), CommandType(command_type), payload)
 
     def read_string(self):
         """
@@ -108,130 +108,93 @@ class CommandDeserializer(object):
 
         :return: Read string
         """
+        self._check_buffer(6)
         p = self.position
         string_encoding_mode = StringEncodingMode(self.buffer[p + 1])
         size = TypeDeserializer.deserialize_int(self.buffer[p + 2:p + 6])
         self.position += 6
+        self._check_buffer(size)
         p = self.position
         self.position += size
         return TypeDeserializer.deserialize_string(string_encoding_mode, self.buffer[p:p + size])
 
     def read_int(self):
-        """
-        Reads an integer from the buffer.
-
-        :return: Read integer
-        """
         size = 4
+        self._check_buffer(size + 2)
         self.position += 2
         p = self.position
         self.position += size
         return TypeDeserializer.deserialize_int(self.buffer[p:p + size])
 
     def read_bool(self):
-        """
-        Reads a boolean from the buffer.
-
-        :return: Read boolean
-        """
         size = 1
+        self._check_buffer(size + 2)
         self.position += 2
         p = self.position
         self.position += size
         return TypeDeserializer.deserialize_bool(self.buffer[p:p + size])
 
     def read_float(self):
-        """
-        Reads a float from the buffer.
-
-        :return: Read float
-        """
         size = 4
+        self._check_buffer(size + 2)
         self.position += 2
         p = self.position
         self.position += size
         return TypeDeserializer.deserialize_float(self.buffer[p:p + size])
 
     def read_byte(self):
-        """
-        Reads a byte from the buffer.
-
-        :return: Read byte
-        """
         size = 1
+        self._check_buffer(size + 2)
         self.position += 2
         p = self.position
         self.position += size
         return TypeDeserializer.deserialize_byte(self.buffer[p:p + size])
 
     def read_char(self):
-        """
-        Reads a character from the buffer.
-
-        :return: Read character
-        """
         size = 1
+        self._check_buffer(size + 2)
         self.position += 2
         p = self.position
         self.position += size
         return TypeDeserializer.deserialize_char(self.buffer[p:p + size])
 
     def read_longlong(self):
-        """
-        Reads a long long from the buffer.
-
-        :return: Read long long
-        """
         size = 8
+        self._check_buffer(size + 2)
         self.position += 2
         p = self.position
         self.position += size
         return TypeDeserializer.deserialize_longlong(self.buffer[p:p + size])
 
     def read_double(self):
-        """
-        Reads a double from the buffer.
-
-        :return: Read double
-        """
         size = 8
+        self._check_buffer(size + 2)
         self.position += 2
         p = self.position
         self.position += size
+
         return TypeDeserializer.deserialize_double(self.buffer[p:p + size])
 
     def read_ullong(self):
-        """
-        Reads an unsigned long long from the buffer.
-
-        :return: Read unsigned long long
-        """
         size = 8
+        self._check_buffer(size + 2)
         self.position += 2
         p = self.position
         self.position += size
         return TypeDeserializer.deserialize_ullong(self.buffer[p:p + size])
 
     def read_uint(self):
-        """
-        Reads an unsigned integer from the buffer.
-
-        :return: Read unsigned integer
-        """
         size = 4
+        self._check_buffer(size + 2)
         self.position += 2
         p = self.position
         self.position += size
         return TypeDeserializer.deserialize_uint(self.buffer[p:p + size])
 
     def read_none(self):
-        """
-        Reads a None value from the buffer.
-
-        :return: Read None value
-        """
         size = 1
+        self._check_buffer(size + 2)
         self.position += 2
         p = self.position
         self.position += size
-        return TypeDeserializer.deserialize_none(self.buffer[p:p + size]) 
+        return TypeDeserializer.deserialize_none(self.buffer[p:p + size])

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/receiver/Receiver.py

@@ -7,6 +7,10 @@ from javonet.core.protocol.CommandSerializer import CommandSerializer
 from javonet.utils.RuntimeLogger import RuntimeLogger
 from javonet.utils.connectionData.InMemoryConnectionData import InMemoryConnectionData
 from javonet.core.protocol.CommandDeserializer import CommandDeserializer
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
+from javonet.utils.RuntimeName import RuntimeName
+from javonet.utils.exception.ExceptionSerializer import ExceptionSerializer
 
 
 class Receiver(object):
@@ -18,11 +22,18 @@ class Receiver(object):
         self.connection_data = InMemoryConnectionData()
 
     def SendCommand(self, message_byte_array_as_string, messageByteArrayLen):
-        message_byte_array = bytearray(message_byte_array_as_string)
-        response_command = Interpreter().process(message_byte_array)
-        serialized_response = CommandSerializer().serialize(response_command, self.connection_data)
-        response_byte_array = bytearray(serialized_response)
-        return response_byte_array
+        try:
+            message_byte_array = bytearray(message_byte_array_as_string)
+            response_command = Interpreter().process(message_byte_array)
+            serialized_response = CommandSerializer().serialize(response_command, self.connection_data)
+            return bytearray(serialized_response)
+        except Exception as ex:
+            exception_command = ExceptionSerializer.serialize_exception(
+                ex,
+                Command(RuntimeName.python27, CommandType.Exception, [])
+            )
+            serialized_exception = CommandSerializer().serialize(exception_command, self.connection_data)
+            return bytearray(serialized_exception)
 
     def HeartBeat(self, message_byte_array_as_string, messageByteArrayLen):
         message_byte_array = bytearray(message_byte_array_as_string)

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/utils/exception/ExceptionSerializer.py

@@ -7,10 +7,10 @@ import os
 import sys
 import traceback
 
-from javonet.utils.PythonStringBuilder import PythonStringBuilder
 from javonet.utils.ExceptionType import ExceptionType
 from javonet.utils.Command import Command
 from javonet.utils.CommandType import CommandType
+from javonet.utils.RuntimeName import RuntimeName
 
 
 class ExceptionSerializer(object):
@@ -36,43 +36,89 @@ class ExceptionSerializer(object):
         :param command: Command that caused the exception
         :return: Command containing the serialized exception
         """
-        exception_command = Command(command.runtime_name, CommandType.Exception, [])
-        
-        # In Python 2 there's no __traceback__, we use sys.exc_info()
-        _, _, tb = sys.exc_info()
-        trace = traceback.extract_tb(tb)
-        exception_message = str(exception)
-        
-        # In Python 2 there's no __cause__, we use the exception type directly
-        exception_name = exception.__class__.__name__
-        
-        stack_classes = PythonStringBuilder()
-        stack_methods = PythonStringBuilder()
-        stack_lines = PythonStringBuilder()
-        stack_files = PythonStringBuilder()
-
-        is_debug = False
-
-        for frame in trace:
-            # In Python 2 extract_tb returns tuples (filename, line number, function name, text)
-            filename, lineno, name, _ = frame
-            if "javonet" not in filename or is_debug:
-                stack_classes.append(ExceptionSerializer.format_class_name_from_file(filename)).append("|")
-                stack_methods.append(name).append("|")
-                stack_lines.append(str(lineno)).append("|")
-                stack_files.append(filename).append("|")
-
-        exception_command = exception_command.add_arg_to_payload(ExceptionSerializer.get_exception_code(exception_name))
-        exception_command = exception_command.add_arg_to_payload(str(command))
-        exception_command = exception_command.add_arg_to_payload(exception_name)
-        exception_command = exception_command.add_arg_to_payload(str(exception_message))
-        exception_command = exception_command.add_arg_to_payload(stack_classes.__str__())
-        exception_command = exception_command.add_arg_to_payload(stack_methods.__str__())
-        exception_command = exception_command.add_arg_to_payload(stack_lines.__str__())
-        exception_command = exception_command.add_arg_to_payload(stack_files.__str__())
+        exception_command = Command(RuntimeName.python27, CommandType.Exception, [])
+        stack_classes = []
+        stack_methods = []
+        stack_lines = []
+        stack_files = []
+
+        try:
+            _, _, tb = sys.exc_info()
+            trace = traceback.extract_tb(tb)
+            exception_message = str(exception)
+
+            exception_name = exception.__class__.__name__
+
+            for frame in trace:
+                class_name = ExceptionSerializer.safe_get_class_name(frame)
+                method_name = ExceptionSerializer.safe_get_method_name(frame)
+                file_name = ExceptionSerializer.safe_get_file_name(frame)
+                line = ExceptionSerializer.safe_get_line(frame)
+
+                if "javonet" not in class_name and "reflect" not in class_name:
+                    stack_classes.append(class_name)
+                    stack_methods.append(method_name)
+                    stack_lines.append(str(line))
+                    stack_files.append(file_name)
+
+            stack_classes_str = "|".join(stack_classes)
+            stack_methods_str = "|".join(stack_methods)
+            stack_lines_str = "|".join(stack_lines)
+            stack_files_str = "|".join(stack_files)
+
+            exception_command = exception_command.add_arg_to_payload(
+                ExceptionSerializer.get_exception_code(exception_name))
+            exception_command = exception_command.add_arg_to_payload(str(command) if command else "Command is null")
+            exception_command = exception_command.add_arg_to_payload(exception_name)
+            exception_command = exception_command.add_arg_to_payload(str(exception_message))
+            exception_command = exception_command.add_arg_to_payload(stack_classes_str)
+            exception_command = exception_command.add_arg_to_payload(stack_methods_str)
+            exception_command = exception_command.add_arg_to_payload(stack_lines_str)
+            exception_command = exception_command.add_arg_to_payload(stack_files_str)
+
+        except Exception as ex:
+            exception_command = Command(command.runtime_name, CommandType.Exception, [])
+            exception_command = exception_command.add_arg_to_payload(
+                ExceptionSerializer.get_exception_code(ex.__class__.__name__))
+
+            exception_command = exception_command.add_arg_to_payload(str(command) if command else "Command is null")
+            exception_command = exception_command.add_arg_to_payload("Python Exception Serialization Error")
+            exception_command = exception_command.add_arg_to_payload(str(ex))
+            exception_command = exception_command.add_arg_to_payload("ExceptionSerializer")
+            exception_command = exception_command.add_arg_to_payload("serialize_exception")
+            exception_command = exception_command.add_arg_to_payload("undefined")
+            exception_command = exception_command.add_arg_to_payload("ExceptionSerializer.py")
 
         return exception_command
 
+    @staticmethod
+    def safe_get_class_name(frame):
+        try:
+            return ExceptionSerializer.format_class_name_from_file(frame[0])
+        except Exception:
+            return "undefined"
+
+    @staticmethod
+    def safe_get_method_name(frame):
+        try:
+            return frame[2] if frame[2] else "undefined"
+        except Exception:
+            return "undefined"
+
+    @staticmethod
+    def safe_get_file_name(frame):
+        try:
+            return frame[0] if frame[0] else "undefined"
+        except Exception:
+            return "undefined"
+
+    @staticmethod
+    def safe_get_line(frame):
+        try:
+            return frame[1] if frame[1] >= 0 else 0
+        except Exception:
+            return 0
+
     @staticmethod
     def get_exception_code(exception_name):
         """
@@ -91,4 +137,4 @@ class ExceptionSerializer(object):
         :param filename: File name
         :return: Class name
         """
-        return os.path.splitext((os.path.split(filename)[1]))[0] 
+        return os.path.splitext((os.path.split(filename)[1]))[0]

data/lib/javonet-ruby-sdk/Binaries/version.txt

@@ -1 +1 @@
-2.6.0
+2.6.2

data/lib/javonet-ruby-sdk/{Binaries/Ruby/Windows/X64/core/receiver/receiver.rb → core/receiver/receiver_new.rb}

@@ -2,6 +2,7 @@ require_relative '../interpreter/interpreter'
 require_relative '../../utils/runtime_logger'
 require_relative '../protocol/command_serializer'
 require_relative '../../utils/command'
+require_relative '../../utils/os_helper'
 
 class Receiver
 
@@ -11,7 +12,7 @@ class Receiver
 
   def send_command(message_array, message_array_len)
     begin
-      CommandSerializer.new.serialize(Interpreter.new.process(message_array))
+      response_array = CommandSerializer.new.serialize(Interpreter.new.process(message_array))
     rescue Exception => e
       message = "Error occurred in Javonet Ruby Core: #{e.message}"
       puts message
@@ -24,12 +25,14 @@ class Receiver
       exception_command = exception_command.add_arg_to_payload("send_command")
       exception_command = exception_command.add_arg_to_payload("undefined")
       exception_command = exception_command.add_arg_to_payload(__FILE__)
-      CommandSerializer.new.serialize(exception_command)
+      response_array = CommandSerializer.new.serialize(exception_command)
     end
+      [response_array.length, response_array]
   end
 
   def heart_beat(message_array, message_array_len)
-    [49,48]
+    response_array = [49, 48]
+    [response_array.length, response_array]
   end
 
   def get_runtime_info

data/lib/javonet-ruby-sdk/utils/os_helper.rb

@@ -0,0 +1,21 @@
+class OSHelper
+  def self.windows?
+    RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/i
+  end
+
+  def self.mac?
+    RbConfig::CONFIG['host_os'] =~ /darwin/i
+  end
+
+  def self.linux?
+    RbConfig::CONFIG['host_os'] =~ /linux/i
+  end
+
+  def self.unix?
+    RbConfig::CONFIG['host_os'] =~ /unix/i
+  end
+
+  def self.os_name
+    RbConfig::CONFIG['host_os']
+  end
+end