javonet-ruby-sdk 2.5.13 → 2.5.15

data/lib/javonet-ruby-sdk/Binaries/Ruby/Windows/X64/core/protocol/command_deserializer.rb

@@ -2,18 +2,19 @@ require_relative 'type_deserializer'
 require_relative '../../utils/type'
 require_relative '../../utils/command'
 require_relative '../../utils/string_encoding_mode'
+require_relative '../../utils/command_type'
+require_relative '../../utils/runtime_name'
 
 class CommandDeserializer
-
   def initialize(buffer)
     @buffer = buffer
-    @byte_array_len = buffer.length
+    @buffer_len = buffer.length
     @command = Command.new(buffer[0], buffer[10], [])
     @position = 11
   end
 
   def is_at_end
-    @position == @byte_array_len
+    @position == @buffer_len
   end
 
   def deserialize
@@ -23,11 +24,6 @@ class CommandDeserializer
     @command
   end
 
-  # def copy_from(self, bytes_to_copy, elements_to_skip):
-  #     size = len(bytes_to_copy) - elements_to_skip
-  #     new_byte_array = bytes_to_copy[size]
-  #     return new_byte_array
-
   def read_object(type_num)
     case type_num
     when Type::COMMAND
@@ -65,19 +61,34 @@ class CommandDeserializer
     runtime = @buffer[p + 5]
     command_type = @buffer[p + 6]
     @position += 7
-    return_command = Command.new(runtime, command_type, [])
-    read_command_recursively(number_of_elements_in_payload, return_command)
-  end
 
-  def read_command_recursively(number_of_elements_in_payload_left, cmd)
-    if number_of_elements_in_payload_left == 0
-      cmd
-    else
-      p = @position
-      cmd = cmd.add_arg_to_payload(self.read_object(@buffer[p]))
-      read_command_recursively(number_of_elements_in_payload_left - 1, cmd)
+    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
-  end
+    Command.new(runtime, command_type, payload)
+  end
+
+  # old implementation
+  #  def read_command
+  #    p = @position
+  #    number_of_elements_in_payload = TypeDeserializer.deserialize_int(@buffer[p + 1..p + 4])
+  #    runtime = @buffer[p + 5]
+  #    command_type = @buffer[p + 6]
+  #    @position += 7
+  #    return_command = Command.new(runtime, command_type, [])
+  #    read_command_recursively(number_of_elements_in_payload, return_command)
+  #  end
+  #
+  #  def read_command_recursively(number_of_elements_in_payload_left, cmd)
+  #    if number_of_elements_in_payload_left == 0
+  #      cmd
+  #    else
+  #      p = @position
+  #      cmd = cmd.add_arg_to_payload(self.read_object(@buffer[p]))
+  #      read_command_recursively(number_of_elements_in_payload_left - 1, cmd)
+  #    end
+  #  end
 
   def read_string
     p = @position
@@ -86,7 +97,7 @@ class CommandDeserializer
     @position += 6
     p = @position
     @position += size
-    TypeDeserializer.deserialize_string(string_encoding_mode, @buffer[p..p + size - 1])
+    TypeDeserializer.deserialize_string(string_encoding_mode, @buffer[p...p + size])
   end
 
   def read_int
@@ -94,7 +105,7 @@ class CommandDeserializer
     @position += 2
     p = @position
     @position += size
-    TypeDeserializer.deserialize_int(@buffer[p..p + size - 1])
+    TypeDeserializer.deserialize_int(@buffer[p...p + size])
   end
 
   def read_bool
@@ -102,7 +113,7 @@ class CommandDeserializer
     @position += 2
     p = @position
     @position += size
-    TypeDeserializer.deserialize_bool(@buffer[p..p + size])
+    TypeDeserializer.deserialize_bool(@buffer[p...p + size])
   end
 
   def read_float
@@ -110,7 +121,7 @@ class CommandDeserializer
     @position += 2
     p = @position
     @position += size
-    TypeDeserializer.deserialize_float(@buffer[p..p + size - 1])
+    TypeDeserializer.deserialize_float(@buffer[p...p + size])
   end
 
   def read_byte
@@ -118,7 +129,7 @@ class CommandDeserializer
     @position += 2
     p = @position
     @position += size
-    TypeDeserializer.deserialize_byte(@buffer[p..p + size])
+    TypeDeserializer.deserialize_byte(@buffer[p...p + size])
   end
 
   def read_char
@@ -126,7 +137,7 @@ class CommandDeserializer
     @position += 2
     p = @position
     @position += size
-    TypeDeserializer.deserialize_char(@buffer[p..p + size])
+    TypeDeserializer.deserialize_char(@buffer[p...p + size])
   end
 
   def read_longlong
@@ -134,7 +145,7 @@ class CommandDeserializer
     @position += 2
     p = @position
     @position += size
-    TypeDeserializer.deserialize_longlong(@buffer[p..p + size - 1])
+    TypeDeserializer.deserialize_longlong(@buffer[p...p + size])
   end
 
   def read_double
@@ -142,7 +153,7 @@ class CommandDeserializer
     @position += 2
     p = @position
     @position += size
-    TypeDeserializer.deserialize_double(@buffer[p..p + size - 1])
+    TypeDeserializer.deserialize_double(@buffer[p...p + size])
   end
 
   def read_ullong
@@ -150,7 +161,7 @@ class CommandDeserializer
     @position += 2
     p = @position
     @position += size
-    TypeDeserializer.deserialize_ullong(@buffer[p..p + size - 1])
+    TypeDeserializer.deserialize_ullong(@buffer[p...p + size])
   end
 
   def read_uint
@@ -158,7 +169,7 @@ class CommandDeserializer
     @position += 2
     p = @position
     @position += size
-    TypeDeserializer.deserialize_uint(@buffer[p..p + size - 1])
+    TypeDeserializer.deserialize_uint(@buffer[p...p + size])
   end
 
   def read_nil
@@ -166,6 +177,6 @@ class CommandDeserializer
     @position += 2
     p = @position
     @position += size
-    TypeDeserializer.deserialize_nil(@buffer[p..p + size])
+    TypeDeserializer.deserialize_nil(@buffer[p...p + size])
   end
 end

data/lib/javonet-ruby-sdk/Binaries/Ruby/Windows/X64/core/protocol/command_serializer.rb

@@ -4,34 +4,32 @@ require_relative '../../utils/runtime_name'
 require_relative '../../utils/tcp_connection_data'
 
 class CommandSerializer
-  def initialize
-    @buffer = []
-  end
-
   def serialize(root_command, connection_data = nil, runtime_version = 0)
-    insert_into_buffer([root_command.runtime_name, runtime_version])
-    if connection_data.nil?
-      insert_into_buffer([0, 0, 0, 0, 0, 0, 0])
+    buffer = []
+    buffer << root_command.runtime_name
+    buffer << runtime_version
+
+    if connection_data
+      buffer.concat(connection_data.serialize_connection_data)
     else
-      insert_into_buffer(connection_data.serialize_connection_data)
+      buffer.concat([0, 0, 0, 0, 0, 0, 0])
     end
-    insert_into_buffer([RuntimeName::PYTHON, root_command.command_type])
-    serialize_recursively(root_command)
-    @buffer
+
+    buffer << RuntimeName::RUBY
+    buffer << root_command.command_type
+
+    serialize_recursively(root_command, buffer)
+    buffer
   end
 
-  def serialize_recursively(command)
+  def serialize_recursively(command, buffer)
     command.payload.each do |item|
       if item.is_a?(Command)
-        insert_into_buffer(TypeSerializer.serialize_command(item))
-        serialize_recursively(item)
+        buffer.concat(TypeSerializer.serialize_command(item))
+        serialize_recursively(item, buffer)
       else
-        insert_into_buffer(TypeSerializer.serialize_primitive(item))
+        buffer.concat(TypeSerializer.serialize_primitive(item))
       end
     end
   end
-
-  def insert_into_buffer(arguments)
-    @buffer += arguments
-  end
 end

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

data/lib/javonet-ruby-sdk/Binaries/Ruby/Windows/X64/core/protocol/type_serializer.rb

@@ -5,21 +5,21 @@ class TypeSerializer
 
   def self.serialize_primitive(payload_item)
     if payload_item.nil?
-      return TypeSerializer.serialize_nil
+      return serialize_nil
     elsif [true, false].include? payload_item
-      return TypeSerializer.serialize_bool(payload_item)
+      return serialize_bool(payload_item)
     elsif payload_item.is_a? Integer
-      if (-2 ** 31..2 ** 31).include?(payload_item)
-        return TypeSerializer.serialize_int(payload_item)
-      elsif (-2 ** 63..2 ** 63).include?(payload_item)
-        return TypeSerializer.serialize_longlong(payload_item)
+      if (-2 ** 31..2 ** 31 - 1).include?(payload_item)
+        return serialize_int(payload_item)
+      elsif (-2 ** 63..2 ** 63 - 1).include?(payload_item)
+        return serialize_longlong(payload_item)
       else
-        return TypeSerializer.serialize_ullong(payload_item)
+        return serialize_ullong(payload_item)
       end
     elsif payload_item.is_a? String
-      return TypeSerializer.serialize_string(payload_item)
+      return serialize_string(payload_item)
     elsif payload_item.is_a? Float
-      return TypeSerializer.serialize_double(payload_item)
+      return serialize_double(payload_item)
     elsif payload_item.is_a?
     else
       raise Exception.new("Payload not supported in command serializer")
@@ -27,18 +27,18 @@ class TypeSerializer
   end
 
   def self.serialize_command(command)
-    length = [command.payload.length].pack("i").bytes
+    length = int_to_bytes(command.payload.length)
     return [Type::COMMAND] + length + [command.runtime_name, command.command_type]
   end
 
   def self.serialize_string(string_value)
     encoded_string_list = string_value.bytes
-    length = [encoded_string_list.length].pack("i").bytes
+    length = int_to_bytes(encoded_string_list.length)
     return [Type::JAVONET_STRING, StringEncodingMode::UTF8] + length + encoded_string_list
   end
 
   def self.serialize_int(int_value)
-    encoded_int_list = [int_value].pack("i").bytes
+    encoded_int_list = int_to_bytes(int_value)
     length = encoded_int_list.length
     return [Type::JAVONET_INTEGER, length] + encoded_int_list
   end
@@ -50,43 +50,43 @@ class TypeSerializer
   end
 
   def self.serialize_float(float_value)
-    encoded_float_list = [float_value].pack("f").bytes
+    encoded_float_list = float_to_bytes(float_value)
     length = encoded_float_list.length
     return [Type::JAVONET_FLOAT, length] + encoded_float_list
   end
 
   def self.serialize_byte(byte_value)
-    encoded_byte_list = [byte_value].pack("c").bytes
+    encoded_byte_list = [byte_value & 0xFF]
     length = encoded_byte_list.length
     return [Type::JAVONET_BYTE, length] + encoded_byte_list
   end
 
   def self.serialize_char(char_value)
-    encoded_char_list = [char_value].pack("c").bytes
+    encoded_char_list = [char_value & 0xFF]
     length = encoded_char_list.length
     return [Type::JAVONET_CHAR, length] + encoded_char_list
   end
 
   def self.serialize_longlong(longlong_value)
-    encoded_longlong_list = [longlong_value].pack("q").bytes
+    encoded_longlong_list = longlong_to_bytes(longlong_value)
     length = encoded_longlong_list.length
     return [Type::JAVONET_LONG_LONG, length] + encoded_longlong_list
   end
 
   def self.serialize_double(double_value)
-    encoded_double_list = [double_value].pack("d").bytes
+    encoded_double_list = double_to_bytes(double_value)
     length = encoded_double_list.length
     return [Type::JAVONET_DOUBLE, length] + encoded_double_list
   end
 
   def self.serialize_uint(uint_value)
-    encoded_uint_list = [uint_value].pack("I").bytes
+    encoded_uint_list = uint_to_bytes(uint_value)
     length = encoded_uint_list.length
     return [Type::JAVONET_UNSIGNED_INTEGER, length] + encoded_uint_list
   end
 
   def self.serialize_ullong(ullong_value)
-    encoded_ullong_list = [ullong_value].pack("Q").bytes
+    encoded_ullong_list = ullong_to_bytes(ullong_value)
     length = encoded_ullong_list.length
     return [Type::JAVONET_UNSIGNED_LONG_LONG, length] + encoded_ullong_list
   end
@@ -95,4 +95,165 @@ class TypeSerializer
     return [Type::JAVONET_NULL, 1, 0]
   end
 
-end
+  # Helper methods for byte conversion
+  def self.int_to_bytes(value)
+    # Convert to 4-byte (32-bit) integer, little-endian
+    [
+      value & 0xFF,
+      (value >> 8) & 0xFF,
+      (value >> 16) & 0xFF,
+      (value >> 24) & 0xFF
+    ]
+  end
+
+  def self.uint_to_bytes(value)
+    # Convert to 4-byte unsigned integer, little-endian
+    [
+      value & 0xFF,
+      (value >> 8) & 0xFF,
+      (value >> 16) & 0xFF,
+      (value >> 24) & 0xFF
+    ]
+  end
+
+  def self.longlong_to_bytes(value)
+    # Convert to 8-byte (64-bit) integer, little-endian
+    [
+      value & 0xFF,
+      (value >> 8) & 0xFF,
+      (value >> 16) & 0xFF,
+      (value >> 24) & 0xFF,
+      (value >> 32) & 0xFF,
+      (value >> 40) & 0xFF,
+      (value >> 48) & 0xFF,
+      (value >> 56) & 0xFF
+    ]
+  end
+
+  def self.ullong_to_bytes(value)
+    # Convert to 8-byte unsigned long long, little-endian
+    [
+      value & 0xFF,
+      (value >> 8) & 0xFF,
+      (value >> 16) & 0xFF,
+      (value >> 24) & 0xFF,
+      (value >> 32) & 0xFF,
+      (value >> 40) & 0xFF,
+      (value >> 48) & 0xFF,
+      (value >> 56) & 0xFF
+    ]
+  end
+
+  def self.float_to_bytes(value)
+    # IEEE 754 single-precision binary floating-point format (32-bit)
+    # Manual implementation without using pack
+    bits = 0
+
+    if value == 0
+      # Zero is a special case
+      return [0, 0, 0, 0]
+    elsif value.nan?
+      # NaN is another special case
+      bits = 0x7FC00000
+    elsif value.infinite?
+      # Handle infinity
+      bits = value > 0 ? 0x7F800000 : 0xFF800000
+    else
+      # Regular number
+      sign = value < 0 ? 1 : 0
+      value = value.abs
+
+      # Get exponent and fraction
+      exponent = Math.log2(value).floor
+      fraction = value / (2.0**exponent) - 1.0
+
+      # Normalize exponent for IEEE 754 bias
+      biased_exponent = exponent + 127
+
+      # Clamp exponent to valid range
+      if biased_exponent <= 0
+        # Denormalized values
+        biased_exponent = 0
+        fraction = value / (2.0**(-126))
+      elsif biased_exponent >= 255
+        # Overflow, return infinity
+        biased_exponent = 255
+        fraction = 0
+      end
+
+      # Assemble the bits
+      fraction_bits = (fraction * 0x800000).round & 0x7FFFFF
+      bits = (sign << 31) | (biased_exponent << 23) | fraction_bits
+    end
+
+    # Convert to bytes (little-endian)
+    [
+      bits & 0xFF,
+      (bits >> 8) & 0xFF,
+      (bits >> 16) & 0xFF,
+      (bits >> 24) & 0xFF
+    ]
+  end
+
+  def self.double_to_bytes(value)
+    # IEEE 754 double-precision binary floating-point format (64-bit)
+    # Manual implementation without using pack
+    bits_low = 0
+    bits_high = 0
+
+    if value == 0
+      # Zero is a special case
+      return [0, 0, 0, 0, 0, 0, 0, 0]
+    elsif value.nan?
+      # NaN is another special case
+      bits_high = 0x7FF80000
+      bits_low = 0
+    elsif value.infinite?
+      # Handle infinity
+      bits_high = value > 0 ? 0x7FF00000 : 0xFFF00000
+      bits_low = 0
+    else
+      # Regular number
+      sign = value < 0 ? 1 : 0
+      value = value.abs
+
+      # Get exponent and fraction
+      exponent = Math.log2(value).floor
+      fraction = value / (2.0**exponent) - 1.0
+
+      # Normalize exponent for IEEE 754 bias
+      biased_exponent = exponent + 1023
+
+      # Clamp exponent to valid range
+      if biased_exponent <= 0
+        # Denormalized values
+        biased_exponent = 0
+        fraction = value / (2.0**(-1022))
+      elsif biased_exponent >= 2047
+        # Overflow, return infinity
+        biased_exponent = 2047
+        fraction = 0
+      end
+
+      # Assemble the bits
+      # Convert fraction to 52-bit integer
+      fraction_bits = (fraction * 0x10000000000000).round
+
+      # Split into high and low 32-bit words
+      bits_high = (sign << 31) | (biased_exponent << 20) | ((fraction_bits >> 32) & 0xFFFFF)
+      bits_low = fraction_bits & 0xFFFFFFFF
+    end
+
+    # Convert to bytes (little-endian)
+    [
+      bits_low & 0xFF,
+      (bits_low >> 8) & 0xFF,
+      (bits_low >> 16) & 0xFF,
+      (bits_low >> 24) & 0xFF,
+      bits_high & 0xFF,
+      (bits_high >> 8) & 0xFF,
+      (bits_high >> 16) & 0xFF,
+      (bits_high >> 24) & 0xFF
+    ]
+  end
+end

data/lib/javonet-ruby-sdk/Binaries/Ruby/Windows/X64/core/receiver/receiver.rb

@@ -5,7 +5,7 @@ require_relative '../protocol/command_serializer'
 class Receiver
 
   def initialize
-    puts RuntimeLogger.print_runtime_info
+    #RuntimeLogger.print_runtime_info
   end
 
   def send_command(message_array, message_array_len)

data/lib/javonet-ruby-sdk/Binaries/Ruby/Windows/X64/core/reference_cache/references_cache.rb

@@ -1,22 +1,24 @@
-require_relative './../../external_lib/singleton'
-require_relative './../../external_lib/securerandom'
-
 class ReferencesCache
-  include Singleton
+  # Make 'new' a private class method so no other instances can be created.
+  private_class_method :new
+
+  def self.instance
+    @instance ||= new
+  end
 
   def initialize
-    @references_cache = Hash.new
+    @references_cache = {}
   end
 
   def cache_reference(object_reference)
-    uuid_ = SecureRandom.uuid
+    uuid_ = generate_uuid
     @references_cache[uuid_] = object_reference
     uuid_
   end
 
   def resolve_reference(guid)
     if @references_cache[guid].nil?
-      raise 'Unable to resolve reference with id: ' + guid.to_s
+      raise "Unable to resolve reference with id: #{guid}"
     else
       @references_cache[guid]
     end
@@ -30,4 +32,8 @@ class ReferencesCache
       0
     end
   end
-end
+
+  def generate_uuid
+    [8, 4, 4, 4, 12].map { |n| rand(16**n).to_s(16).rjust(n, '0') }.join('-')
+  end
+end