javonet-ruby-sdk 2.1.12 → 2.1.13

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

@@ -5,122 +5,157 @@ require_relative '../../utils/string_encoding_mode'
 
 class CommandDeserializer
 
-
-    def initialize(buffer,byte_array_len)
-        @buffer = buffer
-        @byte_array_len = byte_array_len
-        @command = Command.new(buffer[0], buffer[10], [])
-        @position = 11
-    end
-
-    def is_at_end
-        return @position == @byte_array_len
-    end
-
-    def decode
-        until is_at_end
-            @command = @command.add_arg_to_payload(read_object(@buffer[@position]))
-        end
-        return @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)
-        type_value = type_num
-        if type_value == Type::COMMAND
-            return self.read_command
-        elsif type_value == Type::JAVONET_INTEGER
-            return self.read_int
-        elsif type_value == Type::JAVONET_STRING
-            return self.read_string
-        elsif type_value == Type::JAVONET_BOOLEAN
-            return self.read_bool
-        elsif type_value == Type::JAVONET_FLOAT
-            return self.read_float
-        elsif type_value == Type::JAVONET_DOUBLE
-            return self.read_double
-        else
-            Exception("Type not supported")
-        end
+  def initialize(buffer, byte_array_len)
+    @buffer = buffer
+    @byte_array_len = byte_array_len
+    @command = Command.new(buffer[0], buffer[10], [])
+    @position = 11
+  end
+
+  def is_at_end
+    @position == @byte_array_len
+  end
+
+  def deserialize
+    until is_at_end
+      @command = @command.add_arg_to_payload(read_object(@buffer[@position]))
     end
-
-
-    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, [])
-        return 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
-            return cmd
-        else
-            p = @position
-            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
-
+    @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
+      return self.read_command
+    when Type::JAVONET_STRING
+      return self.read_string
+    when Type::JAVONET_INTEGER
+      return self.read_int
+    when Type::JAVONET_BOOLEAN
+      return self.read_bool
+    when Type::JAVONET_FLOAT
+      return self.read_float
+    when Type::JAVONET_BYTE
+      return self.read_byte
+    when Type::JAVONET_CHAR
+      return self.read_char
+    when Type::JAVONET_LONG_LONG
+      return self.read_longlong
+    when Type::JAVONET_DOUBLE
+      return self.read_double
+    when Type::JAVONET_UNSIGNED_LONG_LONG
+      return self.read_ullong
+    when Type::JAVONET_UNSIGNED_INTEGER
+      return self.read_uint
+    else
+      raise Exception.new("Type #{type_num} not supported in command deserializer")
     end
-
-    def read_int
-        @position += 2
-        p = @position
-        @position += 4
-        return TypeDeserializer.deserialize_int(@buffer[p..p + 4 - 1])
-    end
-
-
-    def read_string
-        p = @position
-        string_encoding_mode = @buffer[p+1]
-        size = TypeDeserializer.deserialize_int(@buffer[p+2..p + 5])
-        @position += 6
-        p = @position
-        decoded_string = TypeDeserializer.deserialize_string(string_encoding_mode, @buffer[p..p + size-1])
-        @position += size
-        return decoded_string
-    end
-
-    def read_bool
-        p = @position
-        size = @buffer[p + 1]
-        @position += 2
-        p = @position
-        decoded_bool = TypeDeserializer.deserialize_bool(@buffer[p..p + size])
-        @position += size
-        return decoded_bool
-    end
-
-
-    def read_float
-        p = @position
-        size = @buffer[p + 1]
-        @position += 2
-        p = @position
-        decoded_float = TypeDeserializer.deserialize_float(@buffer[p..p + size - 1])
-        @position += size
-        return decoded_float
-    end
-
-
-    def read_double
-        p = @position
-        size = @buffer[p + 1]
-        @position += 2
-        p = @position
-        decoded_double = TypeDeserializer.deserialize_double(@buffer[p..p + size -1])
-        @position += size
-        return decoded_double
+  end
+
+  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
+    string_encoding_mode = @buffer[p + 1]
+    size = TypeDeserializer.deserialize_int(@buffer[p + 2..p + 5])
+    @position += 6
+    p = @position
+    @position += size
+    TypeDeserializer.deserialize_string(string_encoding_mode, @buffer[p..p + size - 1])
+  end
+
+  def read_int
+    size = 4
+    @position += 2
+    p = @position
+    @position += size
+    TypeDeserializer.deserialize_int(@buffer[p..p + size - 1])
+  end
+
+  def read_bool
+    size = 1
+    @position += 2
+    p = @position
+    @position += size
+    TypeDeserializer.deserialize_bool(@buffer[p..p + size])
+  end
+
+  def read_float
+    size = 4
+    @position += 2
+    p = @position
+    @position += size
+    TypeDeserializer.deserialize_float(@buffer[p..p + size - 1])
+  end
+
+  def read_byte
+    size = 1
+    @position += 2
+    p = @position
+    @position += size
+    TypeDeserializer.deserialize_byte(@buffer[p..p + size])
+  end
+
+  def read_char
+    size = 1
+    @position += 2
+    p = @position
+    @position += size
+    TypeDeserializer.deserialize_char(@buffer[p..p + size])
+  end
+
+  def read_longlong
+    size = 8
+    @position += 2
+    p = @position
+    @position += size
+    TypeDeserializer.deserialize_longlong(@buffer[p..p + size - 1])
+  end
+
+  def read_double
+    size = 8
+    @position += 2
+    p = @position
+    @position += size
+    TypeDeserializer.deserialize_double(@buffer[p..p + size - 1])
+  end
+
+  def read_ullong
+    size = 8
+    @position += 2
+    p = @position
+    @position += size
+    TypeDeserializer.deserialize_ullong(@buffer[p..p + size - 1])
+  end
+
+  def read_uint
+    size = 4
+    @position += 2
+    p = @position
+    @position += size
+    TypeDeserializer.deserialize_uint(@buffer[p..p + size - 1])
+  end
 end

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

@@ -8,11 +8,10 @@ class CommandSerializer
     @byte_buffer = []
   end
 
-
-  def encode(root_command, connection_type = ConnectionType::IN_MEMORY, tcp_address = nil, runtimeVersion = 0)
+  def serialize(root_command, connection_type = ConnectionType::IN_MEMORY, tcp_address = nil, runtime_version = 0)
     queue = []
     queue.unshift(root_command)
-    self.insert_into_buffer([root_command.runtime_name, runtimeVersion])
+    self.insert_into_buffer([root_command.runtime_name, runtime_version])
     if connection_type == ConnectionType::TCP
       self.insert_into_buffer([ConnectionType::TCP])
       self.insert_into_buffer(self.serialize_tcp(tcp_address))
@@ -22,50 +21,50 @@ class CommandSerializer
       self.insert_into_buffer([0, 0, 0, 0, 0, 0])
     end
     self.insert_into_buffer([RuntimeName::RUBY, root_command.command_type])
-    return self.serialize_recursively(queue)
+    self.serialize_recursively(queue)
   end
 
   def serialize_tcp(tcp_address)
     if tcp_address.kind_of?(Array)
-      return tcp_address
+      tcp_address
     else
       tcp_address_array = tcp_address.split(':')
       tcp_address_ip = tcp_address_array[0].split('.')
       tcp_address_port = tcp_address_array[1]
       tcp_address_bytearray = []
-      for address in tcp_address_ip
+      tcp_address_ip.each { |address|
         tcp_address_bytearray.concat([address.to_i])
-      end
+      }
       port_byte = [tcp_address_port.to_i].pack("s_").bytes
       tcp_address_bytearray.concat(port_byte)
-      return tcp_address_bytearray
-
+      tcp_address_bytearray
     end
 
   end
 
   def serialize_primitive(payload_item)
-    if payload_item.is_a? Integer
-      serialized_int = TypeSerializer.serialize_int(payload_item)
-      return serialized_int
+    if [true, false].include? payload_item
+      TypeSerializer.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)
+      else
+        return TypeSerializer.serialize_ullong(payload_item)
+      end
     elsif payload_item.is_a? String
-      serialized_string = TypeSerializer.serialize_string(payload_item)
-      return serialized_string
+      TypeSerializer.serialize_string(payload_item)
     elsif payload_item.is_a? Float
-      serialized_float = TypeSerializer.serialize_float(payload_item)
-      return serialized_float
-    elsif [true,false].include? payload_item
-      serialized_bool = TypeSerializer.serialize_bool(payload_item)
-      return serialized_bool
+      TypeSerializer.serialize_double(payload_item)
+    elsif payload_item.is_a?
     else
-      return nil
+      raise Exception.new("Payload not supported in command serializer")
     end
   end
 
   def insert_into_buffer(arguments)
-    new_byte_buffer = @byte_buffer + arguments
-    @byte_buffer = new_byte_buffer
-
+    @byte_buffer = @byte_buffer + arguments
   end
 
   def serialize_recursively(queue)
@@ -87,7 +86,7 @@ class CommandSerializer
     else
       queue.shift
     end
-    return self.serialize_recursively(queue)
+    self.serialize_recursively(queue)
   end
 
 end

data/lib/javonet-ruby-sdk/Binaries/Ruby/Linux/X64/core/protocol/type_deserializer.rb

@@ -2,73 +2,60 @@ require_relative '../../utils/string_encoding_mode'
 
 class TypeDeserializer
 
-  def self.deserialize_int(encoded_int)
-    int_value = encoded_int.map(&:chr).join.unpack('i').first
-    return int_value
-  end
-
-  # def self.deserialize_unsigned_int(encoded_unsigned_int)
-  #   unsigned_int_value = struct.unpack("<I", bytearray(encoded_unsigned_int))[0]
-  #   return unsigned_int_value
-  # end
-  #
-  # def self.deserialize_longlong(encoded_longlong)
-  #   longlong_value = struct.unpack("<q", bytearray(encoded_longlong))[0]
-  #   return longlong_value
-  # end
-
-
-  def self.deserialize_double(encoded_double)
-    double_value = encoded_double.map(&:chr).join.unpack('d').first
-    return double_value
+  def self.deserialize_command(command_byte_array)
+    Command.new(RuntimeName(command_byte_array[0]), CommandType(command_byte_array[1]), [])
   end
 
   def self.deserialize_string(string_encoding_mode, encoded_string)
-
     case string_encoding_mode
     when StringEncodingMode::ASCII
-        string_value = encoded_string.pack('C*').force_encoding("US-ASCII").encode("UTF-8")
+      encoded_string.pack('C*').force_encoding("US-ASCII").encode("UTF-8")
     when StringEncodingMode::UTF8
-        string_value = encoded_string.pack("C*").force_encoding("UTF-8").encode("UTF-8")
+      encoded_string.pack("C*").force_encoding("UTF-8").encode("UTF-8")
     when StringEncodingMode::UTF16
-        string_value = encoded_string.pack("C*").force_encoding("UTF-16LE").encode("UTF-8")
+      encoded_string.pack("C*").force_encoding("UTF-16LE").encode("UTF-8")
     when StringEncodingMode::UTF32
-        string_value = encoded_string.pack("C*").force_encoding("UTF-32").encode("UTF-8")
+      encoded_string.pack("C*").force_encoding("UTF-32").encode("UTF-8")
     else
-        raise "Argument out of range in deserialize_string"
+      raise "Argument out of range in deserialize_string"
     end
 
-    return string_value
   end
 
-  def self.deserialize_float(encoded_float)
-    float_value = encoded_float.map(&:chr).join.unpack('f').first
-    return float_value
+  def self.deserialize_int(encoded_int)
+    encoded_int.map(&:chr).join.unpack('i').first
   end
 
   def self.deserialize_bool(encoded_bool)
-    if encoded_bool[0] == 1
-      bool_value = true
-    else
-      bool_value = false
-    end
+    encoded_bool[0] == 1
+  end
 
-    return bool_value
+  def self.deserialize_float(encoded_float)
+    encoded_float.map(&:chr).join.unpack('f').first
   end
 
-  # def self.deserialize_char(encoded_char)
-  #   char_value = struct.unpack("<c", bytearray(encoded_char))[0]
-  #   return char_value
-  # end
-  #
-  # def self.deserialize_bytes(encoded_bytes)
-  #   bytes_value = struct.unpack("<c", bytearray(encoded_bytes))[0]
-  #   return bytes_value
-  # end
+  def self.deserialize_byte(encoded_byte)
+    encoded_byte[0]
+  end
 
-  def self.deserialize_command(command_byte_array)
-    python_command = Command.new(RuntimeName(command_byte_array[0]), CommandType(command_byte_array[1]), [])
-    return python_command
+  def self.deserialize_char(encoded_char)
+    encoded_char[0].ord
+  end
+
+  def self.deserialize_longlong(encoded_long)
+    encoded_long.map(&:chr).join.unpack('q').first
+  end
+
+  def self.deserialize_double(encoded_double)
+    encoded_double.map(&:chr).join.unpack('d').first
+  end
+
+  def self.deserialize_ullong(encoded_ullong)
+    encoded_ullong.map(&:chr).join.unpack('Q').first
+  end
+
+  def self.deserialize_uint(encoded_uint)
+    encoded_uint.map(&:chr).join.unpack('I').first
   end
 
-end
+end

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

@@ -3,8 +3,15 @@ require_relative '../../utils/string_encoding_mode'
 
 class TypeSerializer
 
-  def self.serialize_type(type_value)
-      return TypeSerializer.serialize_int(type_value)
+  def self.serialize_command(command)
+    length = [command.payload.length].pack("i").bytes
+    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
+    return [Type::JAVONET_STRING, StringEncodingMode::UTF8] + length + encoded_string_list
   end
 
   def self.serialize_int(int_value)
@@ -13,56 +20,52 @@ class TypeSerializer
     return [Type::JAVONET_INTEGER, length] + encoded_int_list
   end
 
-  def self.serialize_unsigned_int(unsigned_int_value)
-      encoded_unsigned_int_list = [unsigned_int_value].pack("I").bytes
-      length = len(encoded_unsigned_int_list)
-      return [Type::JAVONET_UNSIGNED_INTEGER, length] + encoded_unsigned_int_list
+  def self.serialize_bool(bool_value)
+    encoded_bool_list = bool_value ? [1] : [0]
+    length = encoded_bool_list.length
+    return [Type::JAVONET_BOOLEAN, length] + encoded_bool_list
   end
 
-  # def serialize_longlong(longlong_value)
-  #     encoded_longlong_list = list(bytearray(struct.pack("<q", longlong_value)))
-  #     length = len(encoded_longlong_list)
-  #     return [Type::JAVONET_LONG_LONG, length] + encoded_longlong_list
-  # end
-  #
-  # def serialize_unsignedlonglong(unsigned_longlong_value)
-  #     encoded_unsignedlonglong_list = list(bytearray(struct.pack("<q", unsigned_longlong_value)))
-  #     length = len(encoded_unsignedlonglong_list)
-  #     return [Type::JAVONET_UNSIGNED_LONG_LONG, length] + encoded_unsignedlonglong_list
-  # end
+  def self.serialize_float(float_value)
+    encoded_float_list = [float_value].pack("f").bytes
+    length = encoded_float_list.length
+    return [Type::JAVONET_FLOAT, length] + encoded_float_list
+  end
 
-  def self.serialize_double(double_value)
-      encoded_double_list = [double_value].pack("d").bytes
-      length = encoded_double_list.length
-      return [Type::JAVONET_DOUBLE, length] + encoded_double_list
+  def self.serialize_byte(byte_value)
+    encoded_byte_list = [byte_value].pack("c").bytes
+    length = encoded_byte_list.length
+    return [Type::JAVONET_BYTE, length] + encoded_byte_list
   end
 
-  def self.serialize_string(string_value)
-      encoded_string_list = string_value.bytes
-      length = [encoded_string_list.length].pack("i").bytes
-      return [Type::JAVONET_STRING, StringEncodingMode::UTF8] + length + encoded_string_list
+  def self.serialize_char(char_value)
+    encoded_char_list = [char_value].pack("c").bytes
+    length = encoded_char_list.length
+    return [Type::JAVONET_CHAR, length] + encoded_char_list
   end
 
-  def self.serialize_float(float_value)
-      encoded_float_list = [float_value].pack("f").bytes
-      length = encoded_float_list.length
-      return [Type::JAVONET_FLOAT, length] + encoded_float_list
+  def self.serialize_longlong(longlong_value)
+    encoded_longlong_list = [longlong_value].pack("q").bytes
+    length = encoded_longlong_list.length
+    return [Type::JAVONET_LONG_LONG, length] + encoded_longlong_list
   end
 
-  def self.serialize_bool(bool_value)
-    if bool_value
-      encoded_bool_list = [1]
-    else
-      encoded_bool_list = [0]
-    end
-      length = encoded_bool_list.length
-      return [Type::JAVONET_BOOLEAN, length] + encoded_bool_list
+  def self.serialize_double(double_value)
+    encoded_double_list = [double_value].pack("d").bytes
+    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
+    length = encoded_uint_list.length
+    return [Type::JAVONET_UNSIGNED_INTEGER, length] + encoded_uint_list
+  end
 
-  def self.serialize_command(command)
-      length = [command.payload.length()].pack("i").bytes
-      return [Type::COMMAND] + length + [command.runtime_name, command.command_type]
+  def self.serialize_ullong(ullong_value)
+    encoded_ullong_list = [ullong_value].pack("Q").bytes
+    length = encoded_ullong_list.length
+    return [Type::JAVONET_UNSIGNED_LONG_LONG, length] + encoded_ullong_list
   end
 
 end

data/lib/javonet-ruby-sdk/Binaries/Ruby/Linux/X64/utils/type.rb

@@ -4,7 +4,7 @@ class Type
   JAVONET_INTEGER = 2
   JAVONET_BOOLEAN = 3
   JAVONET_FLOAT = 4
-  JAVONET_BYTES = 5
+  JAVONET_BYTE = 5
   JAVONET_CHAR = 6
   JAVONET_LONG_LONG = 7
   JAVONET_DOUBLE = 8

data/lib/javonet-ruby-sdk/Binaries/Ruby/MacOs/X64/core/interpreter/interpreter.rb

@@ -6,7 +6,7 @@ class Interpreter
   def execute(command, connection_type, tcp_address)
 
     command_serializer = CommandSerializer.new
-    message_byte_array = command_serializer.encode(command, connection_type, tcp_address)
+    message_byte_array = command_serializer.serialize(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)
@@ -16,15 +16,15 @@ class Interpreter
     end
 
     command_deserializer = CommandDeserializer.new(response_byte_array,response_byte_array.length)
-    encoded_response = command_deserializer.decode
+    encoded_response = command_deserializer.deserialize
     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
+    received_command = command_deserializer.deserialize
     handler = Handler.new
     command_serializer = CommandSerializer.new
-    return command_serializer.encode(handler.handle_command(received_command), 0, "0.0.0.0:0")
+    return command_serializer.serialize(handler.handle_command(received_command), 0, "0.0.0.0:0")
   end
 end