javonet-ruby-sdk 2.5.20 → 2.6.0

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

@@ -0,0 +1,108 @@
+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_type.rb

@@ -41,6 +41,10 @@ class CommandType
   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
@@ -128,6 +132,12 @@ class CommandType
       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

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

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

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

@@ -3,41 +3,61 @@ require_relative './exception_type'
 class ExceptionSerializer
 
   def self.serialize_exception(exception, command)
-    exception_command = Command.new(RuntimeName::RUBY, CommandType::EXCEPTION, [])
+    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_trace = exception.backtrace
-    exception_message = exception.message
-    exception_name = exception.class
-    stack_classes = ""
-    stack_methods = ""
-    stack_lines = ""
-    stack_files = ""
-    stack_trace.each_with_index do |value, index|
-      stack_file, stack_class, stack_line, stack_method = parse_stack_frame(value)
-      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
+      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
-    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)
 
-    return exception_command
+      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)
@@ -50,24 +70,38 @@ class ExceptionSerializer
 
   def self.parse_stack_frame(stack_frame)
     # Extract the file path, line number, and method name using regular expressions
-    match = /(.+):(\d+):in `(.+)'/.match(stack_frame)
-
-    # Extract the name of the file without the full path
-    file_name = File.basename(match[1])
-
-    # Extract the class name and method name
-    method_name = match[3]
-    file_name = File.basename(match[1], ".rb")
-    class_name = file_name.split('_').map(&:capitalize).join('')
-    if method_name =~ /(.+)#(.+)/
-      class_name = $1.split('::')[-1]
-      method_name = $2
+    # 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
-
-    # Return the four variables as an array
-    [match[1], class_name, match[2], method_name]
+    [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"
@@ -87,7 +121,7 @@ class ExceptionSerializer
     when "TypeError"
       return ExceptionType::NULL_POINTER_EXCEPTION
     else
-      return exception_name
+      return ExceptionType::EXCEPTION
     end
   end
 end

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

@@ -0,0 +1,19 @@
+class WsConnectionData
+  attr_accessor :hostname
+
+  def initialize(hostname)
+    @hostname = hostname
+  end
+
+  def connection_type
+    ConnectionType::WEB_SOCKET
+  end
+
+  def serialize_connection_data
+    [connection_type, 0, 0, 0, 0, 0, 0]
+  end
+
+  def ==(other)
+    other.is_a?(WsConnectionData) && @hostname == other.hostname
+  end
+end

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

@@ -1,5 +1,6 @@
 require_relative '../../utils/runtime_name'
 require_relative '../../utils/command_type'
+require_relative '../../utils/command'
 require_relative '../../core/handler/handler_dictionary'
 require_relative '../../core/handler/abstract_handler'
 require_relative '../../core/handler/value_handler'
@@ -88,7 +89,7 @@ class Handler < AbstractHandler
       if TypesHandler.primitive_or_none?(response)
         Command.create_response(response, command.runtime_name)
       elsif response.is_a? Exception
-        return ExceptionSerializer.serialize_exception(response, command)
+        ExceptionSerializer.serialize_exception(response, command)
       else
         reference_cache = ReferencesCache.instance
         guid = reference_cache.cache_reference(response)

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

@@ -18,6 +18,9 @@ class LoadLibraryHandler < AbstractCommandHandler
       else
         assembly_name = command.payload[0]
       end
+      
+      # Check if the library exists:
+      raise LoadError.new("Library not found: #{assembly_name}") unless File.exist?(assembly_name)
       #noinspection RubyResolve
       require(assembly_name)
       @@loaded_libraries.push(assembly_name)
@@ -30,4 +33,4 @@ class LoadLibraryHandler < AbstractCommandHandler
   def self.get_loaded_libraries
     @@loaded_libraries
   end
-end
+end

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

@@ -1,5 +1,7 @@
 require_relative '../reference_cache/references_cache'
 require_relative 'abstract_command_handler'
+require_relative '../../utils/runtime_name'
+require_relative '../../utils/command'
 
 class ResolveInstanceHandler < AbstractCommandHandler
   def initialize
@@ -7,7 +9,7 @@ class ResolveInstanceHandler < AbstractCommandHandler
   end
 
   def process(command)
-    return resolve_reference(command)
+    resolve_reference(command)
   end
 
   def resolve_reference(command)
@@ -15,10 +17,13 @@ class ResolveInstanceHandler < AbstractCommandHandler
       raise ArgumentError.new "Resolve Instance parameters mismatch"
     end
     begin
-      references_cache = ReferencesCache.instance
-      return references_cache.resolve_reference(command.payload[0])
+      if command.runtime_name == RuntimeName::RUBY
+        return ReferencesCache.instance.resolve_reference(command.payload[0])
+      else
+        return new Command(command.runtime_name, CommandType::REFERENCE, command.payload[0])
+      end
     rescue Exception => ex
       return ex
     end
   end
-end
+end

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

@@ -10,6 +10,9 @@ class Interpreter
     if command.runtime_name == RuntimeName::RUBY && connection_type == ConnectionType::IN_MEMORY
       require_relative '../receiver/receiver'
       response_byte_array = Receiver.new.send_command(message_byte_array, message_byte_array.length)
+    elsif connection_type == ConnectionType::WEB_SOCKET
+      require_relative '../web_socket_client/web_socket_client'
+      response_byte_array = WebSocketClient.send_message(connection_data.hostname, message_byte_array)
     else
       require_relative '../transmitter/transmitter'
       response_byte_array = Transmitter.send_command(message_byte_array, message_byte_array.length)

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

@@ -1,17 +1,33 @@
 require_relative '../interpreter/interpreter'
 require_relative '../../utils/runtime_logger'
 require_relative '../protocol/command_serializer'
+require_relative '../../utils/command'
 
 class Receiver
 
   def initialize
-    #RuntimeLogger.print_runtime_info
+    puts get_runtime_info
   end
 
   def send_command(message_array, message_array_len)
-    CommandSerializer.new.serialize(Interpreter.new.process(message_array))
+    begin
+      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__)
+      CommandSerializer.new.serialize(exception_command)
+    end
   end
-  
+
   def heart_beat(message_array, message_array_len)
     [49,48]
   end
@@ -20,3 +36,4 @@ class Receiver
     RuntimeLogger.get_runtime_info(true)
   end
 end
+

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

@@ -0,0 +1,108 @@
+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/MacOs/X64/utils/command_type.rb

@@ -41,6 +41,10 @@ class CommandType
   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
@@ -128,6 +132,12 @@ class CommandType
       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

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

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