javonet-nodejs-sdk 2.5.14 → 2.5.15

package/Binaries/Python2/javonet/utils/exception/ExceptionSerializer.py

@@ -0,0 +1,94 @@
+# -*- coding: utf-8 -*-
+"""
+The ExceptionSerializer class is used for serializing exceptions in Javonet.
+"""
+
+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
+
+
+class ExceptionSerializer(object):
+    """
+    Class for serializing exceptions in Javonet.
+    """
+
+    Exception = 0
+    IOException = 1
+    FileNotFoundException = 2
+    RuntimeException = 3
+    ArithmeticException = 4
+    IllegalArgumentException = 5
+    IndexOutOfBoundsException = 6
+    NullPointerException = 7
+
+    @staticmethod
+    def serialize_exception(exception, command):
+        """
+        Serializes an exception to Javonet command format.
+
+        :param exception: Exception to serialize
+        :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__())
+
+        return exception_command
+
+    @staticmethod
+    def get_exception_code(exception_name):
+        """
+        Returns the exception code based on its name.
+
+        :param exception_name: Exception name
+        :return: Exception code
+        """
+        return ExceptionType.to_enum(exception_name)
+
+    @staticmethod
+    def format_class_name_from_file(filename):
+        """
+        Formats the class name based on the file name.
+
+        :param filename: File name
+        :return: Class name
+        """
+        return os.path.splitext((os.path.split(filename)[1]))[0] 

package/Binaries/Python2/javonet/utils/exception/ExceptionThrower.py

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+"""
+The ExceptionThrower class is used for throwing exceptions in Javonet.
+"""
+
+from javonet.utils.exception.JavonetException import JavonetException
+from javonet.utils.ExceptionType import ExceptionType
+
+
+class ExceptionThrower(object):
+    """
+    Class for throwing exceptions in Javonet.
+    """
+
+    @staticmethod
+    def throw_exception(command_exception):
+        """
+        Throws an exception based on the exception command.
+
+        :param command_exception: Exception command
+        :return: Javonet exception
+        """
+        exception_code = command_exception.payload[0]
+        command = command_exception.payload[1]
+        exception_name = command_exception.payload[2]
+        exception_message = command_exception.payload[3]
+        stack_trace_classes = command_exception.payload[4]
+        stack_trace_methods = command_exception.payload[5]
+        stack_trace_lines = command_exception.payload[6]
+        stack_trace_files = command_exception.payload[7]
+
+        stack_trace_elements = ExceptionThrower.process_stack_trace(
+            stack_trace_classes,
+            stack_trace_methods,
+            stack_trace_lines,
+            stack_trace_files
+        )
+
+        traceback_str = ""
+        for element in stack_trace_elements:
+            traceback_str += "  File \"{0}\", line {1}, in {2}\n".format(
+                element[3], element[2], element[1])
+
+        original_exception = ExceptionType.to_exception(exception_code)
+
+        return ExceptionThrower.create_javonet_exception(
+            original_exception,
+            exception_message,
+            traceback_str
+        )
+
+    @staticmethod
+    def create_javonet_exception(original_exception, exception_message, traceback_str):
+        """
+        Creates and returns a Javonet exception.
+
+        :param original_exception: Original exception
+        :param exception_message: Exception message
+        :param traceback_str: Stack trace
+        :return: Javonet exception
+        """
+        return JavonetException(original_exception.__name__, exception_message, traceback_str)
+
+    @staticmethod
+    def process_stack_trace(stack_trace_classes, stack_trace_methods, stack_trace_lines, stack_trace_files):
+        """
+        Processes stack trace into lists of elements.
+
+        :param stack_trace_classes: Classes in stack trace
+        :param stack_trace_methods: Methods in stack trace
+        :param stack_trace_lines: Line numbers in stack trace
+        :param stack_trace_files: Files in stack trace
+        :return: List of stack trace element lists
+        """
+        stack_trace_elements = []
+        if stack_trace_classes:
+            classes = stack_trace_classes.split("|")
+            methods = stack_trace_methods.split("|")
+            lines = stack_trace_lines.split("|")
+            files = stack_trace_files.split("|")
+
+            for i in range(len(classes) - 1):
+                stack_trace_elements.append([classes[i], methods[i], lines[i], files[i]])
+
+        return stack_trace_elements 

package/Binaries/Python2/javonet/utils/exception/JavonetException.py

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+"""
+The JavonetException class represents a Javonet-specific exception.
+"""
+
+
+class JavonetException(Exception):
+    """
+    Class representing a Javonet-specific exception.
+    """
+
+    def __init__(self, name, message, traceback_str):
+        """
+        Initializes a new Javonet exception.
+
+        :param name: Exception name
+        :param message: Exception message
+        :param traceback_str: Stack trace
+        """
+        super(JavonetException, self).__init__(message)
+        self.name = name
+        self.message = message
+        self.traceback_str = traceback_str
+
+    def __str__(self):
+        """
+        Returns the string representation of the exception.
+
+        :return: String representation of the exception
+        """
+        return "{0}: {1}\n{2}".format(self.name, self.message, self.traceback_str) 

package/Binaries/Python2/javonet/utils/exception/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""
+The exception package contains classes for handling exceptions in Javonet.
+""" 

package/Binaries/Ruby/Linux/X64/core/handler/get_type_handler.rb

@@ -21,15 +21,16 @@ class GetTypeHandler < AbstractCommandHandler
         raise "Type #{command.payload[0]} not found.\n"
       end
 
-      if (@namespace_cache.is_namespace_cache_empty? && @type_cache.is_type_cache_empty?) || # both caches are empty
-        @namespace_cache.is_type_allowed(type_to_return) || # namespace is allowed
-        @type_cache.is_type_allowed(type_to_return)
-        # continue - type is allowed
-      else
-        allowed_namespaces = @namespace_cache.get_cached_namespaces.join(", ")
-        allowed_types = @type_cache.get_cached_types.join(", ")
-        raise "Type #{type_to_return.name} not allowed. \nAllowed namespaces: #{allowed_namespaces}\nAllowed types: #{allowed_types}"
-      end
+      # there is a issue with @namespace_cache.empty? and @type_cache.empty? while using ruby through javonet. it has to be turned off
+      # if (@namespace_cache.is_namespace_cache_empty? && @type_cache.is_type_cache_empty?) || # both caches are empty
+      #   @namespace_cache.is_type_allowed(type_to_return) || # namespace is allowed
+      #   @type_cache.is_type_allowed(type_to_return)
+      #   # continue - type is allowed
+      # else
+      #   allowed_namespaces = @namespace_cache.get_cached_namespaces.join(", ")
+      #   allowed_types = @type_cache.get_cached_types.join(", ")
+      #   raise "Type #{type_to_return.name} not allowed. \nAllowed namespaces: #{allowed_namespaces}\nAllowed types: #{allowed_types}"
+      # end
 
       type_to_return
     rescue Exception => e

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

@@ -1,10 +1,12 @@
-require_relative './../../external_lib/singleton'
-
 class NamespaceCache
-  include Singleton
-
   attr_accessor :namespace_cache
 
+  def self.instance
+    @instance ||= new
+  end
+
+  private_class_method :new
+
   def initialize
     @namespace_cache = []
   end
@@ -18,23 +20,23 @@ class NamespaceCache
   end
 
   def is_type_allowed(type_to_check)
-    if type_to_check.is_a?(Module)
-      name_to_check = type_to_check.name
-    else
-      name_to_check = "#{type_to_check.class.name}"
-    end
+    name_to_check = if type_to_check.is_a?(Module)
+                      type_to_check.name
+                    else
+                      "#{type_to_check.class.name}"
+                    end
 
     @namespace_cache.any? do |pattern|
       /#{pattern}/.match?(name_to_check)
     end
   end
 
-def get_cached_namespaces
-  @namespace_cache
-end
+  def get_cached_namespaces
+    @namespace_cache
+  end
 
-def clear_cache
-  @namespace_cache.clear
-  0
+  def clear_cache
+    @namespace_cache.clear
+    0
+  end
 end
-end

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

@@ -24,7 +24,7 @@ class CommandDeserializer
     @command
   end
 
-    def read_object(type_num)
+  def read_object(type_num)
     case type_num
     when Type::COMMAND
       return self.read_command
@@ -61,7 +61,11 @@ class CommandDeserializer
     runtime = @buffer[p + 5]
     command_type = @buffer[p + 6]
     @position += 7
-    payload = number_of_elements_in_payload.times.map { read_object(@buffer[@position]) }
+
+    payload = Array.new(number_of_elements_in_payload)
+    for i in 0..number_of_elements_in_payload - 1
+      payload[i] = read_object(@buffer[@position])
+    end
     Command.new(runtime, command_type, payload)
   end
 

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

@@ -5,25 +5,30 @@ require_relative '../../utils/tcp_connection_data'
 
 class CommandSerializer
   def serialize(root_command, connection_data = nil, runtime_version = 0)
-    buffer = ''.dup
-    buffer << [root_command.runtime_name, runtime_version].pack('C*')
+    buffer = []
+    buffer << root_command.runtime_name
+    buffer << runtime_version
+
     if connection_data
-      buffer << connection_data.serialize_connection_data.pack('C*')
+      buffer.concat(connection_data.serialize_connection_data)
     else
-      buffer << [0, 0, 0, 0, 0, 0, 0].pack('C*')
+      buffer.concat([0, 0, 0, 0, 0, 0, 0])
     end
-    buffer << [RuntimeName::RUBY, root_command.command_type].pack('C*')
+
+    buffer << RuntimeName::RUBY
+    buffer << root_command.command_type
+
     serialize_recursively(root_command, buffer)
-    buffer.bytes
+    buffer
   end
 
   def serialize_recursively(command, buffer)
     command.payload.each do |item|
       if item.is_a?(Command)
-        buffer << TypeSerializer.serialize_command(item).pack('C*')
+        buffer.concat(TypeSerializer.serialize_command(item))
         serialize_recursively(item, buffer)
       else
-        buffer << TypeSerializer.serialize_primitive(item).pack('C*')
+        buffer.concat(TypeSerializer.serialize_primitive(item))
       end
     end
   end

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

@@ -7,23 +7,30 @@ class TypeDeserializer
   end
 
   def self.deserialize_string(string_encoding_mode, encoded_string)
+    raw_str = encoded_string.map(&:chr).join
     case string_encoding_mode
     when StringEncodingMode::ASCII
-      encoded_string.pack('C*').force_encoding("US-ASCII").encode("UTF-8")
+      raw_str.force_encoding("US-ASCII").encode("UTF-8")
     when StringEncodingMode::UTF8
-      encoded_string.pack("C*").force_encoding("UTF-8").encode("UTF-8")
+      raw_str.force_encoding("UTF-8").encode("UTF-8")
     when StringEncodingMode::UTF16
-      encoded_string.pack("C*").force_encoding("UTF-16LE").encode("UTF-8")
+      raw_str.force_encoding("UTF-16LE").encode("UTF-8")
     when StringEncodingMode::UTF32
-      encoded_string.pack("C*").force_encoding("UTF-32").encode("UTF-8")
+      raw_str.force_encoding("UTF-32").encode("UTF-8")
     else
       raise "Argument out of range in deserialize_string"
     end
-
   end
 
   def self.deserialize_int(encoded_int)
-    encoded_int.map(&:chr).join.unpack('i').first
+    # Assuming a 32-bit little-endian integer.
+    value = 0
+    encoded_int.each_with_index do |byte, index|
+      value |= (byte & 0xFF) << (8 * index)
+    end
+    # Sign extension if the 31st bit is set.
+    value -= (1 << 32) if (value & (1 << 31)) != 0
+    value
   end
 
   def self.deserialize_bool(encoded_bool)
@@ -31,7 +38,27 @@ class TypeDeserializer
   end
 
   def self.deserialize_float(encoded_float)
-    encoded_float.map(&:chr).join.unpack('f').first
+    # Reconstruct the 32-bit integer from the byte array.
+    bits = 0
+    encoded_float.each_with_index do |byte, index|
+      bits |= (byte & 0xFF) << (8 * index)
+    end
+
+    # IEEE 754 single precision (32-bit) decoding:
+    sign     = ((bits >> 31) == 0) ? 1 : -1
+    exponent = (bits >> 23) & 0xFF
+    fraction = bits & 0x7FFFFF
+
+    if exponent == 255
+      # Handle special cases for Inf and NaN.
+      return fraction == 0 ? sign * Float::INFINITY : Float::NAN
+    elsif exponent == 0
+      # Subnormal numbers.
+      return sign * (fraction.to_f / (1 << 23)) * (2 ** (-126))
+    else
+      # Normalized number.
+      return sign * (1 + fraction.to_f / (1 << 23)) * (2 ** (exponent - 127))
+    end
   end
 
   def self.deserialize_byte(encoded_byte)
@@ -43,19 +70,53 @@ class TypeDeserializer
   end
 
   def self.deserialize_longlong(encoded_long)
-    encoded_long.map(&:chr).join.unpack('q').first
+    # Assuming a 64-bit little-endian integer.
+    value = 0
+    encoded_long.each_with_index do |byte, index|
+      value |= (byte & 0xFF) << (8 * index)
+    end
+    # Sign extension for 64-bit: if the 63rd bit is set.
+    value -= (1 << 64) if value >= (1 << 63)
+    value
   end
 
   def self.deserialize_double(encoded_double)
-    encoded_double.map(&:chr).join.unpack('d').first
+    # Reconstruct the 64-bit bit pattern from the byte array.
+    bits = 0
+    encoded_double.each_with_index do |byte, index|
+      bits |= (byte & 0xFF) << (8 * index)
+    end
+
+    # IEEE 754 double precision (64-bit) decoding:
+    sign     = ((bits >> 63) == 0) ? 1 : -1
+    exponent = (bits >> 52) & 0x7FF
+    fraction = bits & 0xFFFFFFFFFFFFF
+
+    if exponent == 2047
+      return fraction == 0 ? sign * Float::INFINITY : Float::NAN
+    elsif exponent == 0
+      return sign * (fraction.to_f / (1 << 52)) * (2 ** (-1022))
+    else
+      return sign * (1 + fraction.to_f / (1 << 52)) * (2 ** (exponent - 1023))
+    end
   end
 
   def self.deserialize_ullong(encoded_ullong)
-    encoded_ullong.map(&:chr).join.unpack('Q').first
+    # Assuming an unsigned 64-bit little-endian integer.
+    value = 0
+    encoded_ullong.each_with_index do |byte, index|
+      value |= (byte & 0xFF) << (8 * index)
+    end
+    value
   end
 
   def self.deserialize_uint(encoded_uint)
-    encoded_uint.map(&:chr).join.unpack('I').first
+    # Assuming an unsigned 32-bit little-endian integer.
+    value = 0
+    encoded_uint.each_with_index do |byte, index|
+      value |= (byte & 0xFF) << (8 * index)
+    end
+    value
   end
 
   def self.deserialize_nil(encoded_nil)