javonet-ruby-sdk 2.5.20 → 2.6.0

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/core/handler/GetKwargHandler.py

@@ -0,0 +1,26 @@
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.utils.CommandType import CommandType
+
+
+class GetKwargHandler(AbstractCommandHandler):
+
+    def __init__(self):
+        self._required_parameters_count = 2
+
+    def process(self, command):
+        try:
+            if len(command.payload) < self._required_parameters_count:
+                raise Exception("GetKwargHandler parameters mismatch!")
+
+            # kwargs are passed as a list in the payload as "key1", "value1", "key2", "value2"
+            if len(command.payload) % 2 != 0:
+                raise Exception("GetKwargHandler parameters mismatch! Payload should contain an even number of elements.")
+
+            kwargs = dict(zip(command.payload[::2], command.payload[1::2]))
+            return (CommandType.AsKwargs, kwargs)
+
+
+        except Exception as e:
+            exc_type, exc_value = type(e), e
+            new_exc = exc_type(exc_value).with_traceback(e.__traceback__)
+            raise new_exc from None

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/core/handler/Handler.py

@@ -27,6 +27,8 @@ from javonet.core.handler.GetInstanceMethodAsDelegateHandler import GetInstanceM
 from javonet.core.handler.PassDelegateHandler import PassDelegateHandler
 from javonet.core.handler.InvokeDelegateHandler import InvokeDelegateHandler
 from javonet.core.handler.InvokeGlobalFunctionHandler import InvokeGlobalFunctionHandler
+from javonet.core.handler.ConvertTypeHandler import ConvertTypeHandler
+from javonet.core.handler.GetKwargHandler import GetKwargHandler
 
 
 from javonet.core.handler.HandlerDictionary import handler_dict
@@ -68,6 +70,8 @@ class Handler(AbstractHandler):
         handler_dict[CommandType.PassDelegate] = PassDelegateHandler()
         handler_dict[CommandType.InvokeDelegate] = InvokeDelegateHandler()
         handler_dict[CommandType.InvokeGlobalFunction] = InvokeGlobalFunctionHandler()
+        handler_dict[CommandType.ConvertType] = ConvertTypeHandler()
+        handler_dict[CommandType.AsKwargs] = GetKwargHandler()
 
     def handle_command(self, command):
         try:
@@ -91,3 +95,4 @@ class Handler(AbstractHandler):
     @staticmethod
     def __is_response_array(response):
         return isinstance(response, list)
+

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/core/handler/InvokeDelegateHandler.py

@@ -1,5 +1,6 @@
 from javonet.core.delegateCache.DelegatesCache import DelegatesCache
 from javonet.core.handler.AbstractCommandHandler import *
+from javonet.utils.CommandType import CommandType
 
 
 class InvokeDelegateHandler(AbstractCommandHandler):
@@ -9,16 +10,24 @@ class InvokeDelegateHandler(AbstractCommandHandler):
 
     def process(self, command):
         try:
-            if len(command.payload) != self._required_parameters_count:
-                raise Exception("ResolveInstanceHandler parameters mismatch!")
+            if len(command.payload) < self._required_parameters_count:
+                raise Exception(f"{self.__class__.__name__} parameters mismatch")
 
             delegates_cache = DelegatesCache()
-            method = delegates_cache.resolve_delegate(command)
+            method = delegates_cache.get_delegate(command.payload[0])
+            arguments = []
+            kwargs = {}
             if len(command.payload) > 1:
-                method_arguments = command.payload[1:]
-                return method(*method_arguments)
-            else:
-                return method()
+                arguments = command.payload[1:]
+
+                last_arg = arguments[-1]
+                if isinstance(last_arg, tuple) and last_arg[0] == CommandType.AsKwargs:
+                    if not isinstance(last_arg[1], dict):
+                        raise ValueError("Kwargs must be a dictionary, got: " + str(type(last_arg[1]).__name__))
+                    kwargs = last_arg[1]
+                    arguments = arguments[:-1]
+
+            return method(*arguments, **kwargs)
         except Exception as e:
             exc_type, exc_value = type(e), e
             new_exc = exc_type(exc_value).with_traceback(e.__traceback__)

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/core/handler/InvokeGlobalFunctionHandler.py

@@ -1,5 +1,6 @@
 import importlib
 from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.utils.CommandType import CommandType
 
 
 class InvokeGlobalFunctionHandler(AbstractCommandHandler):
@@ -37,8 +38,19 @@ class InvokeGlobalFunctionHandler(AbstractCommandHandler):
             if not callable(function):
                 raise Exception(f"Attribute '{function_name}' in module '{module_name}' is not callable.")
 
-            function_args = command.payload[1:]
-            return function(*function_args)
+            arguments = []
+            kwargs = {}
+            if len(command.payload) > 1:
+                arguments = command.payload[1:]
+
+                last_arg = arguments[-1]
+                if isinstance(last_arg, tuple) and last_arg[0] == CommandType.AsKwargs:
+                    if not isinstance(last_arg[1], dict):
+                        raise ValueError("Kwargs must be a dictionary, got: " + str(type(last_arg[1]).__name__))
+                    kwargs = last_arg[1]
+                    arguments = arguments[:-1]
+
+            return function(*arguments, **kwargs)
 
         except Exception as e:
             exc_type, exc_value = type(e), e

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/core/handler/InvokeInstanceMethodHandler.py

@@ -1,4 +1,5 @@
 from javonet.core.handler.AbstractCommandHandler import *
+from javonet.utils.CommandType import CommandType
 
 
 class InvokeInstanceMethodHandler(AbstractCommandHandler):
@@ -20,11 +21,20 @@ class InvokeInstanceMethodHandler(AbstractCommandHandler):
                 for method in methods:
                     message += "{}\n".format(method)
                 raise AttributeError(message)
-            
+
+            arguments = []
+            kwargs = {}
             if len(command.payload) > 2:
-                method_arguments = command.payload[2:]
-                return method(*method_arguments)
-            return method()
+                arguments = command.payload[2:]
+
+                last_arg = arguments[-1]
+                if isinstance(last_arg, tuple) and last_arg[0] == CommandType.AsKwargs:
+                    if not isinstance(last_arg[1], dict):
+                        raise ValueError("Kwargs must be a dictionary, got: " + str(type(last_arg[1]).__name__))
+                    kwargs = last_arg[1]
+                    arguments = arguments[:-1]
+
+            return method(*arguments, **kwargs)
         except Exception as e:
             exc_type, exc_value = type(e), e
             new_exc = exc_type(exc_value).with_traceback(e.__traceback__)

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/core/handler/InvokeStaticMethodHandler.py

@@ -1,4 +1,5 @@
 from javonet.core.handler.AbstractCommandHandler import *
+from javonet.utils.CommandType import CommandType
 
 
 class InvokeStaticMethodHandler(AbstractCommandHandler):
@@ -21,10 +22,20 @@ class InvokeStaticMethodHandler(AbstractCommandHandler):
                     message += "{}\n".format(method)
                 raise AttributeError(message)
             
+            arguments = []
+            kwargs = {}
             if len(command.payload) > 2:
-                method_arguments = command.payload[2:]
-                return method(*method_arguments)
-            return method()
+                arguments = command.payload[2:]
+
+                last_arg = arguments[-1]
+                if isinstance(last_arg, tuple) and last_arg[0] == CommandType.AsKwargs:
+                    if not isinstance(last_arg[1], dict):
+                        raise ValueError("Kwargs must be a dictionary, got: " + str(type(last_arg[1]).__name__))
+                    kwargs = last_arg[1]
+                    arguments = arguments[:-1]
+
+            return method(*arguments, **kwargs)
+
         except Exception as e:
             exc_type, exc_value = type(e), e
             new_exc = exc_type(exc_value).with_traceback(e.__traceback__)

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/core/handler/PassDelegateHandler.py

@@ -1,21 +1,49 @@
-from javonet.core.delegateCache.DelegatesCache import DelegatesCache
-from javonet.core.handler.AbstractCommandHandler import *
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.utils.CommandType import CommandType
+from javonet.utils.RuntimeName import RuntimeName
+from javonet.utils.connectionData.InMemoryConnectionData import InMemoryConnectionData
+from javonet.utils.Command import Command
+from javonet.utils.exception.ExceptionThrower import ExceptionThrower
 
 
 class PassDelegateHandler(AbstractCommandHandler):
-
-    def __init__(self):
-        self._required_parameters_count = 1
+    _required_parameters_count = 1
 
     def process(self, command):
         try:
-            if len(command.payload) != self._required_parameters_count:
-                raise Exception("ResolveInstanceHandler parameters mismatch!")
+            if len(command.payload) < self._required_parameters_count:
+                raise Exception(f"{self.__class__.__name__} parameters mismatch")
+
+            delegate_guid = command.payload[0]
+            calling_runtime = RuntimeName(command.payload[1])
+
+            # not used in this context, but kept for reference
+            #parameters_from_command = command.payload[2:] if len(command.payload) > 2 else []
+            #delegate_param_types = parameters_from_command[:-1]
+            #delegate_return_type = parameters_from_command[-1] if parameters_from_command else None
+
+            def dynamic_delegate(*args):
+                # Prepare the command to invoke the delegate
+                args_array = [delegate_guid] + list(args)
+                invoke_delegate_command = Command(
+                    calling_runtime,
+                    CommandType.InvokeDelegate,
+                    args_array
+                )
+                from javonet.core.interpreter.Interpreter import Interpreter
+                response = Interpreter().execute(invoke_delegate_command, InMemoryConnectionData())
+                if response.command_type == CommandType.Exception:
+                    raise Exception("Exception occurred while invoking delegate:\n" + str(ExceptionThrower.throw_exception(response)))
+
+                # not used in this context, but kept for reference
+                # if delegate_return_type is not None and delegate_return_type.__name__ == "JavonetVoidType":
+                #     return None
+
+                return response.payload[0] if response.payload else None
+
+            return dynamic_delegate
 
-            # TO BE IMPLEMENTED
         except Exception as e:
             exc_type, exc_value = type(e), e
             new_exc = exc_type(exc_value).with_traceback(e.__traceback__)
-            raise new_exc from None
-
-
+            raise new_exc from None

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/core/handler/ResolveInstanceHandler.py

@@ -1,5 +1,7 @@
 from javonet.core.handler.AbstractCommandHandler import *
 from javonet.core.referenceCache.ReferencesCache import ReferencesCache
+from javonet.utils.CommandType import CommandType
+from javonet.utils.RuntimeName import RuntimeName
 
 
 class ResolveInstanceHandler(AbstractCommandHandler):
@@ -11,8 +13,10 @@ class ResolveInstanceHandler(AbstractCommandHandler):
             if len(command.payload) != self._required_parameters_count:
                 raise Exception("ResolveInstanceHandler parameters mismatch!")
 
-            references_cache = ReferencesCache()
-            return references_cache.resolve_reference(command)
+            if command.runtime_name == RuntimeName.python:
+                return ReferencesCache().resolve_reference(command)
+            else:
+                return Command(command.runtime_name, CommandType.Reference, command.payload[0])
         except Exception as e:
             exc_type, exc_value = type(e), e
             new_exc = exc_type(exc_value).with_traceback(e.__traceback__)

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/core/receiver/Receiver.py

@@ -3,8 +3,12 @@ import traceback
 
 from javonet.core.interpreter.Interpreter import Interpreter
 from javonet.core.protocol.CommandSerializer import CommandSerializer
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
 from javonet.utils.RuntimeLogger import RuntimeLogger
+from javonet.utils.RuntimeName import RuntimeName
 from javonet.utils.connectionData.InMemoryConnectionData import InMemoryConnectionData
+from javonet.utils.exception.ExceptionSerializer import ExceptionSerializer
 from javonet.utils.messageHelper.MessageHelper import MessageHelper
 
 
@@ -30,7 +34,15 @@ class Receiver:
         sys.excepthook = custom_excepthook
 
     def SendCommand(self, message_byte_array, messageByteArrayLen):
-        return bytearray(CommandSerializer().serialize(Interpreter().process(message_byte_array), self.connection_data))
+        try:
+            result = Interpreter().process(message_byte_array)
+            return bytearray(CommandSerializer().serialize(result, self.connection_data))
+        except Exception as ex:
+            exception_command = ExceptionSerializer.serialize_exception(
+                ex,
+                Command(RuntimeName.python, CommandType.Exception, [])
+            )
+            return bytearray(CommandSerializer().serialize(exception_command, self.connection_data))
 
     def HeartBeat(self, message_byte_array, messageByteArrayLen):
         response_byte_array = bytearray(2)

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/core/transmitter/TransmitterWrapper.py

@@ -13,24 +13,38 @@ class TransmitterWrapper:
     @staticmethod
     def get_native_lib():
         if TransmitterWrapper._python_lib is None:
-            file_path = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+
             machine = platform.machine().lower()
             if '64' in machine:
                 arch = 'X64'
             elif 'arm' in machine:
                 arch = 'ARM64' if '64' in machine else 'ARM'
-            else:
+            elif '32' in machine or 'i386' in machine:
                 arch = 'X86'
+            else:
+                raise RuntimeError("Unsupported architecture: " + machine)
 
             if platform.system() == 'Windows':
-                python_lib_path = file_path + f'/Binaries/Native/Windows/{arch}/JavonetPythonRuntimeNative.dll'
+                os_name = 'Windows'
+                lib_name = 'JavonetPythonRuntimeNative.dll'
             elif platform.system() == 'Linux':
-                python_lib_path = file_path + f'/Binaries/Native/Linux/{arch}/libJavonetPythonRuntimeNative.so'
+                os_name = 'Linux'
+                lib_name = 'libJavonetPythonRuntimeNative.so'
             elif platform.system() == 'Darwin':
-                python_lib_path = file_path + f'/Binaries/Native/MacOs/{arch}/libJavonetPythonRuntimeNative.dylib'
+                os_name = 'MacOs'
+                lib_name = 'libJavonetPythonRuntimeNative.dylib'
             else:
-                raise RuntimeError("Unsupported OS: " + platform.system())
-            lib = cdll.LoadLibrary(python_lib_path)
+                raise RuntimeError("Unsupported operating system: " + platform.system())
+
+            relative_path = f'Binaries/Native/{os_name}/{arch}/{lib_name}'
+            native_lib_path = os.path.join(os.path.curdir, relative_path)
+
+            if not os.path.exists(native_lib_path):
+                this_file_path = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+                native_lib_path = os.path.join(this_file_path, relative_path)
+
+
+            lib = cdll.LoadLibrary(native_lib_path)
             lib.SetCallback(callbackFunction)
             TransmitterWrapper._python_lib = lib
         return TransmitterWrapper._python_lib

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/utils/CommandType.py

@@ -44,3 +44,7 @@ class CommandType(Enum):
     PassDelegate = 39
     InvokeDelegate = 40
     ConvertType = 41
+    AddEventListener = 42
+    PluginWrapper = 43
+    GetAsyncOperationResult = 44
+    AsKwargs = 45

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/utils/exception/ExceptionSerializer.py

@@ -4,50 +4,94 @@ import traceback
 from javonet.utils.ExceptionType import ExceptionType
 from javonet.utils.Command import Command
 from javonet.utils.CommandType import CommandType
+from javonet.utils.RuntimeName import RuntimeName
 
 
 class ExceptionSerializer:
 
     @staticmethod
     def serialize_exception(exception, command):
-        exception_command = Command(command.runtime_name, CommandType.Exception, [])
-        tb = exception.__traceback__
-        trace = traceback.extract_tb(tb)
-        exception_message = str(exception)
-        exception_name = exception.__cause__.__class__.__name__
-
-        # Use lists to collect strings, then join using the pipe separator.
+        exception_command = Command(RuntimeName.python, CommandType.Exception, [])
         stack_classes = []
         stack_methods = []
         stack_lines = []
         stack_files = []
 
-        is_debug = False
-
-        for frame_summary in trace:
-            if "javonet" not in frame_summary.filename or is_debug:
-                stack_classes.append(ExceptionSerializer.format_class_name_from_file(frame_summary.filename))
-                stack_methods.append(frame_summary.name)
-                stack_lines.append(str(frame_summary.lineno))
-                stack_files.append(frame_summary.filename)
-
-        # Join list items with '|' and add a trailing '|' if needed.
-        stack_classes_str = "|".join(stack_classes) + "|" if stack_classes else ""
-        stack_methods_str = "|".join(stack_methods) + "|" if stack_methods else ""
-        stack_lines_str = "|".join(stack_lines) + "|" if stack_lines else ""
-        stack_files_str = "|".join(stack_files) + "|" if stack_files else ""
-
-        exception_command = exception_command.add_arg_to_payload(ExceptionSerializer.get_exception_code(exception_name))
-        exception_command = exception_command.add_arg_to_payload(str(command))
-        exception_command = exception_command.add_arg_to_payload(exception_name)
-        exception_command = exception_command.add_arg_to_payload(str(exception_message))
-        exception_command = exception_command.add_arg_to_payload(stack_classes_str)
-        exception_command = exception_command.add_arg_to_payload(stack_methods_str)
-        exception_command = exception_command.add_arg_to_payload(stack_lines_str)
-        exception_command = exception_command.add_arg_to_payload(stack_files_str)
+        try:
+            tb = exception.__traceback__
+            trace = traceback.extract_tb(tb)
+            exception_message = str(exception)
+            exception_name = exception.__class__.__name__
+
+            for frame_summary in trace:
+                class_name = ExceptionSerializer.safe_get_class_name(frame_summary)
+                method_name = ExceptionSerializer.safe_get_method_name(frame_summary)
+                file_name = ExceptionSerializer.safe_get_file_name(frame_summary)
+                line = ExceptionSerializer.safe_get_line(frame_summary)
+
+                if "javonet" not in class_name and "reflect" not in class_name:
+                    stack_classes.append(class_name)
+                    stack_methods.append(method_name)
+                    stack_lines.append(str(line))
+                    stack_files.append(file_name)
+
+            stack_classes_str = "|".join(stack_classes)
+            stack_methods_str = "|".join(stack_methods)
+            stack_lines_str = "|".join(stack_lines)
+            stack_files_str = "|".join(stack_files)
+
+            exception_command = exception_command.add_arg_to_payload(
+                ExceptionSerializer.get_exception_code(exception_name))
+            exception_command = exception_command.add_arg_to_payload(str(command))
+            exception_command = exception_command.add_arg_to_payload(exception_name)
+            exception_command = exception_command.add_arg_to_payload(str(exception_message))
+            exception_command = exception_command.add_arg_to_payload(stack_classes_str)
+            exception_command = exception_command.add_arg_to_payload(stack_methods_str)
+            exception_command = exception_command.add_arg_to_payload(stack_lines_str)
+            exception_command = exception_command.add_arg_to_payload(stack_files_str)
+
+        except Exception as ex:
+            exception_command = Command(RuntimeName.python, CommandType.Exception, [])
+            exception_command = exception_command.add_arg_to_payload(
+                ExceptionSerializer.get_exception_code(ex.__class__.__name__))
+            exception_command = exception_command.add_arg_to_payload(command if command else "Command is null")
+            exception_command = exception_command.add_arg_to_payload("Python Exception Serialization Error")
+            exception_command = exception_command.add_arg_to_payload(str(ex))
+            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("ExceptionSerializer.py")
 
         return exception_command
 
+    @staticmethod
+    def safe_get_class_name(frame_summary):
+        try:
+            return ExceptionSerializer.format_class_name_from_file(frame_summary.filename)
+        except Exception:
+            return "undefined"
+
+    @staticmethod
+    def safe_get_method_name(frame_summary):
+        try:
+            return frame_summary.name if frame_summary.name else "undefined"
+        except Exception:
+            return "undefined"
+
+    @staticmethod
+    def safe_get_file_name(frame_summary):
+        try:
+            return frame_summary.filename if frame_summary.filename else "undefined"
+        except Exception:
+            return "undefined"
+
+    @staticmethod
+    def safe_get_line(frame_summary):
+        try:
+            return frame_summary.lineno if frame_summary.lineno >= 0 else 0
+        except Exception:
+            return 0
+
     @staticmethod
     def get_exception_code(exception_name):
         return ExceptionType.to_enum(exception_name)

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/handler/ResolveInstanceHandler.py

@@ -23,8 +23,10 @@ class ResolveInstanceHandler(AbstractCommandHandler):
             if len(command.payload) != self._required_parameters_count:
                 raise Exception("ResolveInstanceHandler parameters mismatch!")
 
-            references_cache = ReferencesCache()
-            return references_cache.resolve_reference(command)
+            if command.runtime_name == RuntimeName.python27: 
+                return ReferencesCache().resolve_reference(command)
+            else:
+                return Command(command.runtime_name, CommandType.Reference, command.payload[0])
             
         except Exception as e:
             # W Python 2.7 nie ma with_traceback i from None

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/utils/CommandType.py

@@ -63,6 +63,9 @@ class CommandType(object):
     PassDelegate = None
     InvokeDelegate = None
     ConvertType = None
+    AddEventListener = None
+    PluginWrapper = None
+    GetAsyncOperationResult = None
 
     _name_map = {
         0: 'Value',
@@ -106,7 +109,10 @@ class CommandType(object):
         38: 'GetInstanceMethodAsDelegate',
         39: 'PassDelegate',
         40: 'InvokeDelegate',
-        41: 'ConvertType'
+        41: 'ConvertType',
+        42: 'AddEventListener',
+        43: 'PluginWrapper',
+        44: 'GetAsyncOperationResult'
     }
 
 # Initialize values
@@ -151,4 +157,7 @@ CommandType.GetStaticMethodAsDelegate = CommandType(37)
 CommandType.GetInstanceMethodAsDelegate = CommandType(38)
 CommandType.PassDelegate = CommandType(39)
 CommandType.InvokeDelegate = CommandType(40)
-CommandType.ConvertType = CommandType(41) 
+CommandType.ConvertType = CommandType(41)
+CommandType.AddEventListener = CommandType(42)
+CommandType.PluginWrapper = CommandType(43)
+CommandType.GetAsyncOperationResult = CommandType(44)

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