javonet-ruby-sdk 2.6.3 → 2.6.5

data/lib/javonet-ruby-sdk/core/reference_cache/references_cache.rb

@@ -1,39 +1,39 @@
-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
+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/core/transmitter/transmitter.rb

@@ -1,58 +1,58 @@
-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
+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/core/transmitter/transmitter_wrapper.rb

@@ -1,32 +1,32 @@
-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
+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/core/type_cache/type_cache.rb

@@ -1,42 +1,42 @@
-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
+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/core/web_socket_client/web_socket_client.rb

@@ -1,108 +1,228 @@
-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
+require 'uri'
+require 'socket'
+require 'openssl'
+require 'websocket'
+
+class WebSocketClient
+  class << self
+    def add_or_get_client(url)
+      cache[url] && cache[url].open? ? cache[url] : (cache[url]&.close; cache[url] = new(url))
+    end
+
+    def send_message(url, message)
+      client = add_or_get_client(url)
+      client.send_message(message)
+      return client.receive_message
+    rescue Errno::EPIPE, Errno::ECONNRESET, Errno::ETIMEDOUT, IOError, SystemCallError
+      # Socket likely died due to server idle-timeout; rebuild without sending CLOSE
+      close_client(url, suppress_close_frame: true)
+      client = add_or_get_client(url)
+      client.send_message(message)
+      client.receive_message
+    end
+
+    def close_client(url, suppress_close_frame: false)
+      cache[url]&.close(suppress_close_frame: suppress_close_frame)
+      cache.delete(url)
+    end
+
+    # Returns :OPEN, :CLOSED, or nil (no client)
+    def get_state(url)
+      c = cache[url]
+      return nil unless c
+      c.open? ? :OPEN : :CLOSED
+    end
+
+    private
+
+    def cache
+      @cache ||= {}
+    end
+  end
+
+  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.nil? || @uri.path.empty?) ? '/' : @uri.path
+    @path += "?#{@uri.query}" if @uri.query
+
+    @socket = open_socket
+    @handshake = WebSocket::Handshake::Client.new(url: url) # masks handled by client frames
+    perform_handshake
+    @incoming = WebSocket::Frame::Incoming::Client.new(version: @handshake.version)
+  end
+
+  # message can be an Array<Integer 0..255> or a String of bytes
+  def send_message(message)
+    data =
+      case message
+      when String then message.b
+      when Array  then message.pack('C*')
+      else raise ArgumentError, "Unsupported message type: #{message.class}"
+      end
+
+    frame = WebSocket::Frame::Outgoing::Client.new(
+      version: @handshake.version,
+      data: data,
+      type: :binary
+    )
+    write_all(frame.to_s)
+    true
+  end
+
+  # Returns Array<Integer> (bytes) or nil on timeout
+  def receive_message(timeout: 5)
+    deadline = Time.now + timeout
+    payload_chunks = []
+
+    loop do
+      # try to parse any buffered data first
+      if (frame = @incoming.next)
+        case frame.type
+        when :binary, :text, :continuation
+          payload_chunks << frame.data
+          return payload_chunks.join.bytes
+        when :ping
+          send_pong(frame.data)
+        when :close
+          send_close_reply
+          return nil
+        end
+        next
+      end
+
+      # no complete frame yet—read from socket or timeout
+      remaining = deadline - Time.now
+      return nil if remaining <= 0
+
+      if IO.select([@socket], nil, nil, [remaining, 0.05].max)
+        begin
+          chunk = @socket.read_nonblock(64 * 1024, exception: false)
+          case chunk
+          when nil
+            # peer closed
+            return nil
+          when :wait_readable
+            next
+          else
+            @incoming << chunk
+          end
+        rescue IO::WaitReadable
+          next
+        rescue EOFError
+          return nil
+        end
+      end
+    end
+  end
+
+  def open?
+    return false if @socket.closed?
+    true
+  rescue IOError, SystemCallError
+    false
+  end
+
+  def close(suppress_close_frame: false)
+    begin
+      send_close_reply unless suppress_close_frame || @socket.closed?
+    rescue Errno::EPIPE, Errno::ECONNRESET, IOError, SystemCallError
+      # peer already gone — ignore
+    ensure
+      @socket.close unless @socket.closed?
+    end
+  end
+
+  private
+
+  def default_port
+    @uri.scheme == 'wss' ? 443 : 80
+  end
+
+  def open_socket
+    tcp = TCPSocket.new(@host, @port)
+    tcp.sync = true
+
+    return tcp unless @uri.scheme == 'wss'
+
+    ctx = OpenSSL::SSL::SSLContext.new
+    # NOTE: for production, set VERIFY_PEER and provide a store/ca_file.
+    ctx.set_params(verify_mode: OpenSSL::SSL::VERIFY_NONE)
+
+    ssl = OpenSSL::SSL::SSLSocket.new(tcp, ctx)
+    ssl.sync_close = true
+    ssl.hostname = @host
+    ssl.connect
+    ssl
+  end
+
+  def perform_handshake
+    write_all(@handshake.to_s)
+    # Read until the handshake object reports finished or the server closes
+    loop do
+      break if @handshake.finished?
+      if IO.select([@socket], nil, nil, 5)
+        begin
+          data = @socket.read_nonblock(4096, exception: false)
+          case data
+          when nil
+            break
+          when :wait_readable
+            next
+          else
+            @handshake << data
+          end
+        rescue IO::WaitReadable
+          next
+        end
+      else
+        raise "WebSocket handshake timeout"
+      end
+    end
+
+    raise "WebSocket handshake failed!" unless @handshake.finished? && @handshake.valid?
+  end
+
+  def write_all(data)
+    total = 0
+    while total < data.bytesize
+      written = @socket.write_nonblock(data.byteslice(total..-1), exception: false)
+      case written
+      when :wait_writable
+        IO.select(nil, [@socket])
+        next
+      when 0, nil
+        raise IOError, "socket closed while writing"
+      else
+        total += written
+      end
+    end
+  rescue IO::WaitWritable
+    IO.select(nil, [@socket]); retry
+  rescue Errno::EPIPE, Errno::ECONNRESET
+    # bubble up for send_message to handle reconnect logic
+    raise
+  end
+
+  def send_pong(data)
+    pong = WebSocket::Frame::Outgoing::Client.new(
+      version: @handshake.version, type: :pong, data: data
+    )
+    write_all(pong.to_s)
+  rescue Errno::EPIPE, Errno::ECONNRESET, IOError, SystemCallError
+    # ignore: socket already gone; next send will recreate
+  end
+
+  def send_close_reply
+    return if @socket.closed?
+    frame = WebSocket::Frame::Outgoing::Client.new(
+      version: @handshake.version, type: :close
+    )
+    write_all(frame.to_s)
+  rescue Errno::EPIPE, Errno::ECONNRESET, IOError, SystemCallError
+    # ignore: socket already gone
+  end
+end