javonet-ruby-sdk 2.6.1 → 2.6.2

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

@@ -1,42 +0,0 @@
-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
-
-  def initialize
-    puts get_runtime_info
-  end
-
-  def send_command(message_array, message_array_len)
-    begin
-      response_array = CommandSerializer.new.serialize(Interpreter.new.process(message_array))
-    rescue Exception => e
-      message = "Error occurred in Javonet Ruby Core: #{e.message}"
-      puts message
-      exception_command = Command.new(RuntimeName::RUBY, CommandType::EXCEPTION, [])
-      exception_command = exception_command.add_arg_to_payload(ExceptionType::EXCEPTION)
-      exception_command = exception_command.add_arg_to_payload(Command.new(RuntimeName::RUBY, CommandType::EXCEPTION, ["Ruby Core Error", "Ruby Core Error"]).to_string)
-      exception_command = exception_command.add_arg_to_payload("Ruby Core Error")
-      exception_command = exception_command.add_arg_to_payload(e.message)
-      exception_command = exception_command.add_arg_to_payload("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__)
-      response_array = CommandSerializer.new.serialize(exception_command)
-    end
-      [response_array.length, response_array]
-  end
-
-  def heart_beat(message_array, message_array_len)
-    response_array = [49, 48]
-    [response_array.length, response_array]
-  end
-
-  def get_runtime_info
-    RuntimeLogger.get_runtime_info(true)
-  end
-end
-

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

@@ -1,39 +0,0 @@
-class ReferencesCache
-  # 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 = {}
-  end
-
-  def cache_reference(object_reference)
-    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}"
-    else
-      @references_cache[guid]
-    end
-  end
-
-  def delete_reference(guid)
-    if @references_cache[guid].nil?
-      raise 'Object not found in reference cache'
-    else
-      @references_cache.delete(guid)
-      0
-    end
-  end
-
-  def generate_uuid
-    [8, 4, 4, 4, 12].map { |n| rand(16**n).to_s(16).rjust(n, '0') }.join('-')
-  end
-end

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

@@ -1,58 +0,0 @@
-require 'ffi'
-require 'os'
-require_relative 'transmitter_wrapper'
-
-class Transmitter
-
-  def self.send_command(message_byte_array, message_byte_array_len)
-    message = FFI::MemoryPointer.new(:uchar, message_byte_array_len, true)
-    message.put_array_of_uchar(0, message_byte_array)
-    response_byte_array_len = TransmitterWrapper.SendCommand(message, message_byte_array_len)
-    if response_byte_array_len > 0
-      response = FFI::MemoryPointer.new(:uchar, response_byte_array_len, true)
-      TransmitterWrapper.ReadResponse(response, response_byte_array_len)
-      response_byte_array = response.get_array_of_uchar(0, response_byte_array_len)
-      return response_byte_array
-    elsif response_byte_array_len == 0
-      error_message = "Response is empty"
-      raise Exception.new error_message
-    else
-      error_message = get_native_error
-      raise Exception.new "Javonet native error code: " + response_byte_array_len.to_s + ". " + error_message
-    end
-  end
-
-  def self.activate(license_key)
-    activation_result = TransmitterWrapper.Activate(license_key)
-    if activation_result < 0
-      error_message = get_native_error
-      raise Exception.new "Javonet activation result: " + activation_result.to_s + ". Native error message: " + error_message
-    else
-      return activation_result
-    end
-  end
-
-  def self.get_native_error
-    TransmitterWrapper.GetNativeError
-  end
-
-  def self.set_config_source(config_path)
-    set_config_result = TransmitterWrapper.SetConfigSource(config_path)
-    if set_config_result < 0
-      error_message = get_native_error
-      raise Exception.new "Javonet set config source result: " + set_config_result.to_s + ". Native error message: " + error_message
-    else
-      return set_config_result
-    end
-  end
-
-  def self.set_javonet_working_directory(config_path)
-    set_working_directory_result = TransmitterWrapper.SetWorkingDirectory(config_path)
-    if set_working_directory_result < 0
-      error_message = get_native_error
-      raise Exception.new "Javonet set working directory result: " + set_working_directory_result.to_s + ". Native error message: " + error_message
-    else
-      return set_working_directory_result
-    end
-  end
-end

data/lib/javonet-ruby-sdk/Binaries/Ruby/Linux/X64/core/transmitter/transmitter_wrapper.rb

@@ -1,32 +0,0 @@
-module TransmitterWrapper
-  extend FFI::Library
-
-  arch = case FFI::Platform::ARCH
-         when 'x86_64'
-           'X64'
-         when 'x86'
-           'X86'
-         when 'arm'
-           'ARM'
-         when 'aarch64'
-           'ARM64'
-         else
-           raise "Unsupported architecture: #{FFI::Platform::ARCH}"
-         end
-
-  if OS.linux?
-    ffi_lib File.expand_path("../../../Binaries/Native/Linux/#{arch}/libJavonetRubyRuntimeNative.so", __FILE__)
-  elsif OS.mac?
-    ffi_lib File.expand_path("../../../Binaries/Native/MacOs/#{arch}/libJavonetRubyRuntimeNative.dylib", __FILE__)
-  else
-    RubyInstaller::Runtime.add_dll_directory(File.expand_path("../../../Binaries/Native/Windows/#{arch}/", __FILE__))
-    ffi_lib File.expand_path("../../../Binaries/Native/Windows/#{arch}/JavonetRubyRuntimeNative.dll", __FILE__)
-  end
-
-  attach_function :SendCommand, [:pointer, :int], :int
-  attach_function :ReadResponse, [:pointer, :int], :int
-  attach_function :Activate, [:pointer], :int
-  attach_function :GetNativeError, [], :string
-  attach_function :SetConfigSource, [:pointer], :int
-  attach_function :SetWorkingDirectory, [:pointer], :int
-end

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

@@ -1,42 +0,0 @@
-class TypeCache
-  attr_accessor :type_cache
-
-  def self.instance
-    @instance ||= new
-  end
-
-  private_class_method :new
-
-  def initialize
-    @type_cache = []
-  end
-
-  def cache_type(type_regex)
-    @type_cache << type_regex
-  end
-
-  def is_type_cache_empty?
-    @type_cache.empty?
-  end
-
-  def is_type_allowed(type_to_check)
-    name_to_check = if type_to_check.is_a?(Module)
-                      type_to_check.name
-                    else
-                      "#{type_to_check.class.name}::#{type_to_check.name}"
-                    end
-
-    @type_cache.any? do |pattern|
-      /#{pattern}/.match?(name_to_check)
-    end
-  end
-
-  def get_cached_types
-    @type_cache
-  end
-
-  def clear_cache
-    @type_cache.clear
-    0
-  end
-end

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

@@ -1,108 +0,0 @@
-require 'websocket'
-require 'uri'
-
-class WebSocketClient
-  def initialize(url)
-    @uri = URI.parse(url)
-    raise "Only ws:// or wss:// URLs are supported" unless %w[ws wss].include?(@uri.scheme)
-
-    @host = @uri.host
-    @port = @uri.port || default_port
-    @path = @uri.path.empty? ? '/' : @uri.path
-    @path += "?#{@uri.query}" if @uri.query
-
-    @socket = open_socket
-    @handshake = WebSocket::Handshake::Client.new(
-      url: url
-    )
-
-    perform_handshake
-  end
-
-  def send_message(message)
-    frame = WebSocket::Frame::Outgoing::Client.new(version: @handshake.version, data: message.pack("C*"), type: :binary)
-    @socket.write(frame.to_s)
-  end
-
-  def receive_message(timeout: 5)
-    buffer = ''
-    start_time = Time.now
-
-    while Time.now - start_time < timeout
-      if IO.select([@socket], nil, nil, 0.1)
-        chunk = @socket.read_nonblock(1024, exception: false)
-        break if chunk.nil?
-
-        buffer << chunk
-        frame = WebSocket::Frame::Incoming::Client.new(version: @handshake.version)
-        frame << buffer
-        data = frame.next
-        return data.data.bytes if data
-      end
-    end
-
-    nil
-  end
-
-  def self.add_or_get_client(url)
-    @@clients ||= {}
-    client = @@clients[url]
-    if client.nil? || !client.open?
-      client&.close
-      client = new(url)
-      @@clients[url] = client
-    end
-    client
-  end
-
-  def self.send_message(url, message)
-    client = add_or_get_client(url)
-    client.send_message(message)
-    client.receive_message
-  end
-
-  def open?
-    !@socket.closed?
-  end
-
-  def close
-    frame = WebSocket::Frame::Outgoing::Client.new(version: @handshake.version, type: :close)
-    @socket.write(frame.to_s)
-    @socket.close
-  end
-
-  private
-
-  def default_port
-    @uri.scheme == 'wss' ? 443 : 80
-  end
-
-  def open_socket
-    tcp = TCPSocket.new(@host, @port)
-
-    if @uri.scheme == 'wss'
-      ssl_context = OpenSSL::SSL::SSLContext.new
-      ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
-      ssl = OpenSSL::SSL::SSLSocket.new(tcp, ssl_context)
-      ssl.sync_close = true
-      ssl.hostname = @host
-      ssl.connect
-      ssl
-    else
-      tcp
-    end
-  end
-
-  def perform_handshake
-    @socket.write(@handshake.to_s)
-
-    until @handshake.finished?
-      line = @socket.gets
-      break if line.nil?
-
-      @handshake << line
-    end
-
-    raise "WebSocket handshake failed!" unless @handshake.valid?
-  end
-end

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

@@ -1,93 +0,0 @@
-require_relative 'runtime_name'
-require_relative 'runtime_name_handler'
-require_relative 'command_type'
-
-class Command
-  def initialize(runtime_name, command_type, payload)
-    @runtime_name = runtime_name
-    @command_type = command_type
-    @payload = payload
-  end
-
-  def runtime_name
-    @runtime_name
-  end
-
-  def command_type
-    @command_type
-  end
-
-  def payload
-    @payload
-  end
-
-
-  def self.create_response(response, runtime_name)
-    return Command.new(runtime_name, CommandType::VALUE, [response])
-  end
-
-  def self.create_reference(guid, runtime_name)
-    return Command.new(runtime_name, CommandType::REFERENCE, [guid])
-  end
-
-  def self.create_array_response(array, runtime_name)
-    return Command.new(runtime_name, CommandType::ARRAY, array)
-  end
-
-  def drop_first_payload_argument
-    payload_args = []
-    payload_args = payload_args + @payload
-    if payload_args.length != 0
-      payload_args.delete_at(0)
-    end
-    return Command.new(@runtime_name, @command_type, payload_args)
-  end
-
-  def add_arg_to_payload(argument)
-    merged_payload = payload + [argument]
-    return Command.new(@runtime_name, @command_type, merged_payload)
-  end
-
-  def prepend_arg_to_payload(current_command)
-    if current_command.nil?
-      return Command.new(@runtime_name, @command_type, @payload)
-    else
-      merged_payload = [current_command] + payload
-      return Command.new(@runtime_name, @command_type, merged_payload)
-    end
-  end
-
-  def to_string
-    'Runtime Library: ' + RuntimeNameHandler.get_name(@runtime_name) + ' ' + 'Ruby command type: ' + CommandType.get_name(@command_type).to_s + ' ' + 'with parameters: ' + @payload.to_s
-  end
-
-  def eql?(other)
-    @is_equal = false
-    if self == other
-      @is_equal = true
-    end
-    if other == nil or self.class != other.class
-      @is_equal = false
-    end
-    if self.command_type == other.command_type and self.runtime_name == other.runtime_name
-      @is_equal = true
-    end
-    if payload.length == other.payload.length
-      i = 0
-      array_item_equal = false
-      payload.each { |payload_item|
-        if payload_item.eql? other.payload[i]
-          array_item_equal = true
-        else
-          array_item_equal = false
-        end
-        i += 1
-      }
-      @is_equal = array_item_equal
-    else
-      @is_equal = false
-    end
-    return @is_equal
-  end
-
-end

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

@@ -1,145 +0,0 @@
-class CommandType
-  VALUE = 0
-  LOAD_LIBRARY = 1
-  INVOKE_STATIC_METHOD = 2
-  GET_STATIC_FIELD = 3
-  SET_STATIC_FIELD = 4
-  CREATE_CLASS_INSTANCE = 5
-  GET_TYPE = 6
-  REFERENCE = 7
-  GET_MODULE = 8
-  INVOKE_INSTANCE_METHOD = 9
-  EXCEPTION = 10
-  HEARTBEAT = 11
-  CAST = 12
-  GET_INSTANCE_FIELD = 13
-  OPTIMIZE = 14
-  GENERATE_LIB = 15
-  INVOKE_GLOBAL_FUNCTION = 16
-  DESTRUCT_REFERENCE = 17
-  ARRAY_REFERENCE = 18
-  ARRAY_GET_ITEM = 19
-  ARRAY_GET_SIZE = 20
-  ARRAY_GET_RANK = 21
-  ARRAY_SET_ITEM = 22
-  ARRAY = 23
-  RETRIEVE_ARRAY = 24
-  SET_INSTANCE_FIELD = 25
-  INVOKE_GENERIC_STATIC_METHOD = 26
-  INVOKE_GENERIC_METHOD = 27
-  GET_ENUM_ITEM = 28
-  GET_ENUM_NAME = 29
-  GET_ENUM_VALUE = 30
-  AS_REF = 31
-  AS_OUT = 32
-  GET_REF_VALUE = 33
-  ENABLE_NAMESPACE = 34
-  ENABLE_TYPE = 35
-  CREATE_NULL = 36
-  GET_STATIC_METHOD_AS_DELEGATE = 37
-  GET_INSTANCE_METHOD_AS_DELEGATE = 38
-  PASS_DELEGATE = 39
-  INVOKE_DELEGATE = 40
-  CONVERT_TYPE = 41
-  ADD_EVENT_LISTENER = 42
-  PLUGIN_WRAPPER = 43
-  GET_ASYNC_OPERATION_RESULT = 44
-
-
-  def self.get_name(command_number)
-    case command_number
-    when 0
-      return 'VALUE'
-    when 1
-      return 'LOAD_LIBRARY'
-    when 2
-      return 'INVOKE_STATIC_METHOD'
-    when 3
-      return 'GET_STATIC_FIELD'
-    when 4
-      return 'SET_STATIC_FIELD'
-    when 5
-      return 'CREATE_CLASS_INSTANCE'
-    when 6
-      return 'GET_TYPE'
-    when 7
-      return 'REFERENCE'
-    when 8
-      return 'GET_MODULE'
-    when 9
-      return 'INVOKE_INSTANCE_METHOD'
-    when 10
-      return 'EXCEPTION'
-    when 11
-      return 'HEARTBEAT'
-    when 12
-      return 'CAST'
-    when 13
-      return 'GET_INSTANCE_FIELD'
-    when 14
-      return 'OPTIMIZE'
-    when 15
-      return 'GENERATE_LIB'
-    when 16
-      return 'INVOKE_GLOBAL_FUNCTION'
-    when 17
-      return 'DESTRUCT_REFERENCE'
-    when 18
-      return 'ARRAY_REFERENCE'
-    when 19
-      return 'ARRAY_GET_ITEM'
-    when 20
-      return 'ARRAY_GET_SIZE'
-    when 21
-      return 'ARRAY_GET_RANK'
-    when 22
-      return 'ARRAY_SET_ITEM'
-    when 23
-      return 'ARRAY'
-    when 24
-      return 'RETRIEVE_ARRAY'
-    when 25
-      return 'SET_INSTANCE_FIELD'
-    when 26
-      return 'INVOKE_GENERIC_STATIC_METHOD'
-    when 27
-      return 'INVOKE_GENERIC_METHOD'
-    when 28
-      return 'GET_ENUM_ITEM'
-    when 29
-      return 'GET_ENUM_NAME'
-    when 30
-      return 'GET_ENUM_VALUE'
-    when 31
-      return 'AS_REF'
-    when 32
-      return 'AS_OUT'
-    when 33
-      return 'GET_REF_VALUE'
-    when 34
-      return 'ENABLE_NAMESPACE'
-    when 35
-      return 'ENABLE_TYPE'
-    when 36
-      return 'CREATE_NULL'
-    when 37
-      return 'GET_STATIC_METHOD_AS_DELEGATE'
-    when 38
-      return 'GET_INSTANCE_METHOD_AS_DELEGATE'
-    when 39
-      return 'PASS_DELEGATE'
-    when 40
-      return 'INVOKE_DELEGATE'
-    when 41
-      return 'CONVERT_TYPE'
-    when 42
-      return 'ADD_EVENT_LISTENER'
-    when 43
-      return 'PLUGIN_WRAPPER'
-    when 44
-      return 'GET_ASYNC_OPERATION_RESULT'
-    else
-      raise 'Unknown command type'
-    end
-  end
-end

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

@@ -1,5 +0,0 @@
-class ConnectionType
-  IN_MEMORY = 0
-  TCP = 1
-  WEB_SOCKET = 2
-end

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

@@ -1,127 +0,0 @@
-require_relative './exception_type'
-
-class ExceptionSerializer
-
-  def self.serialize_exception(exception, command)
-    exception_command = Command.new(command.runtime_name, CommandType::EXCEPTION, [])
-    begin
-      stack_trace = exception.backtrace
-      exception_message = exception.message
-      exception_name = "Ruby Exception"
-      #exception_name = exception.class.to_s # does not work - causes native issues
-
-      stack_classes = ""
-      stack_methods = ""
-      stack_lines = ""
-      stack_files = ""
-      if !stack_trace.nil? && !stack_trace.empty?
-        stack_trace.each_with_index do |value, index|
-          stack_file, stack_class, stack_line, stack_method = parse_stack_frame(value)
-          # Extract the file name without the full path - commented for better debugging
-          # To be re-enabled in the future
-          #unless stack_file.include?("javonet-ruby-sdk") or stack_file.include?("Binaries/Ruby")
-            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 # To be re-enabled in the future
-          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)
-    rescue Exception => e
-      exception_command = Command.new(RuntimeName::RUBY, CommandType::EXCEPTION, [])
-      exception_command = exception_command.add_arg_to_payload(ExceptionType::EXCEPTION)
-      if command.nil?
-        exception_command = exception_command.add_arg_to_payload("Command is nil")
-      else
-        exception_command = exception_command.add_arg_to_payload(command.to_string)
-      end
-      exception_command = exception_command.add_arg_to_payload("Ruby Exception Serialization Error")
-      exception_command = exception_command.add_arg_to_payload(e.message)
-      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(__FILE__)
-    end
-    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
-    # Handles both 'Class#method' and '<top (required)>'
-    match = /^(.+):(\d+):in ['`](.+)['`]$/.match(stack_frame)
-    return ["undefined", "undefined", "undefined", "undefined"] if match.nil?
-    stack_file = match[1]
-    stack_line = match[2]
-    method_info = match[3]
-    if method_info =~ /^(.+)#(.+)$/
-      stack_class = $1&.split('::')&.last || 'undefined'
-      stack_method = $2
-    elsif method_info =~ /^<(.+)>$/
-      stack_class = "undefined"
-      stack_method = method_info
-    else
-      stack_class = "undefined"
-      stack_method = method_info
-    end
-    [stack_file, stack_class, stack_line, stack_method]
-  end
-
-  # def self.parse_stack_frame(stack_frame)
-  #   # Match: path:line:in 'Class#method'
-  #   match = /^(.+):(\d+):in\s+'([^#]+)#([^']+)'$/.match(stack_frame)
-  #   return ["undefined", "undefined", "undefined", "undefined"] if match.nil?
-  #
-  #   stack_file = match[1]
-  #   stack_line = match[2]
-  #   stack_class = match[3]
-  #   stack_method = match[4]
-  #
-  #   [stack_file, stack_class, stack_line, stack_method]
-  # 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 ExceptionType::EXCEPTION
-    end
-  end
-end