javonet-nodejs-sdk 2.5.1 → 2.5.3

package/Binaries/Perl/Windows/X64/lib/Javonet/Sdk/Core/RuntimeLogger.pm

@@ -0,0 +1,34 @@
+package Javonet::Sdk::Core::RuntimeLogger;
+use strict;
+use warnings;
+use Config qw(%Config);
+use Cwd;
+use Sys::Hostname;
+
+our $not_logged_yet = 1;
+
+sub get_runtime_info {
+    my $info;
+    eval {
+        $info = "Perl Managed Runtime Info:\n" .
+            "Perl Version: $]\n" .
+            "Perl executable path: $^X\n" .
+            "Perl \@INC Path: @INC\n" .
+            "OS Version: " . $Config{osname} . " " . $Config{osvers} . "\n" .
+            "Process Architecture: " . $Config{archname} . "\n" .
+            "Current Directory: " . getcwd() . "\n";
+    };
+    if ($@) {
+        $info = "Perl Managed Runtime Info: Error while fetching runtime info";
+    }
+    return $info;
+}
+
+sub print_runtime_info {
+    if ($not_logged_yet) {
+        print get_runtime_info();
+        $not_logged_yet = 0;
+    }
+}
+
+1;

package/Binaries/Python/javonet/core/callback/callbackFunc.py

@@ -1,5 +1,7 @@
 def callbackFunc(message_byte_array, message_byte_array_len):
     from javonet.core.receiver.Receiver import Receiver
     python_receiver = Receiver()
-    response = python_receiver.HeartBeat(message_byte_array, message_byte_array_len)
-    return response
+    if message_byte_array[10] == 11:
+        return python_receiver.HeartBeat(message_byte_array, message_byte_array_len)
+    else:
+        return python_receiver.SendCommand(message_byte_array, message_byte_array_len)

package/Binaries/Python/javonet/core/delegateCache/DelegatesCache.py

@@ -0,0 +1,39 @@
+import uuid
+import threading
+from javonet.utils.CommandType import CommandType
+
+
+class DelegatesCache(object):
+    _instance = None
+    delegates_cache = dict()
+    _lock = threading.Lock()  # Initialize a lock object
+
+    def __new__(cls):
+        with cls._lock:
+            if cls._instance is None:
+                cls._instance = super(DelegatesCache, cls).__new__(cls)
+        return cls._instance
+
+    def cache_delegate(self, object_delegate):
+        with self._lock:
+            uuid_ = str(uuid.uuid4())
+            self.delegates_cache[uuid_] = object_delegate
+            return uuid_
+
+    def resolve_delegate(self, command):
+        if command.command_type != CommandType.Reference:
+            raise Exception(
+                "Failed to find delegate")
+        with self._lock:
+            try:
+                return self.delegates_cache[command.payload[0]]
+            except KeyError:
+                raise Exception("Object not found in delegates")
+
+    def delete_delegate(self, delegate_guid):
+        with self._lock:
+            try:
+                del self.delegates_cache[delegate_guid]
+                return 0
+            except KeyError:
+                raise Exception("Object not found in delegates")

package/Binaries/Python/javonet/core/handler/CreateClassInstanceHandler.py

@@ -14,13 +14,7 @@ class CreateClassInstanceHandler(AbstractCommandHandler):
             clazz = command.payload[0]
             if len(command.payload) > 1:
                 method_arguments = command.payload[1:]
-                sig = signature(clazz)
-                if len(sig.parameters) != len(method_arguments):
-                    raise Exception("Number of arguments for create class instance are not matching!")
-                try:
-                    return clazz(*method_arguments)
-                except:
-                    raise Exception("Error while creating class instance!")
+                return clazz(*method_arguments)
             return clazz()
         except Exception as e:
             exc_type, exc_value = type(e), e

package/Binaries/Python/javonet/core/handler/GetInstanceMethodAsDelegateHandler.py

@@ -0,0 +1,29 @@
+from javonet.core.handler.AbstractCommandHandler import *
+
+
+class GetInstanceMethodAsDelegateHandler(AbstractCommandHandler):
+
+    def __init__(self):
+        self._required_parameters_count = 2
+
+    def process(self, command):
+        try:
+            if len(command.payload) < self._required_parameters_count:
+                raise Exception("InvokeInstanceMethod Parameters mismatch!")
+
+            class_instance = command.payload[0]
+            try:
+                method = getattr(class_instance, command.payload[1])
+            except AttributeError:
+                methods = [method for method in dir(class_instance) if callable(getattr(class_instance, method))]
+                message = "Method {} not found in class {}. Available methods:\n".format(command.payload[1],
+                                                                                         class_instance.__class__.__name__)
+                for method in methods:
+                    message += "{}\n".format(method)
+                raise AttributeError(message)
+
+            return method
+        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

package/Binaries/Python/javonet/core/handler/GetStaticMethodAsDelegateHandler.py

@@ -0,0 +1,31 @@
+from javonet.core.handler.AbstractCommandHandler import *
+
+
+class GetStaticMethodAsDelegateHandler(AbstractCommandHandler):
+
+    def __init__(self):
+        self._required_parameters_count = 2
+
+    def process(self, command):
+        try:
+            if len(command.payload) < self._required_parameters_count:
+                raise Exception("InvokeStaticMethod Parameters mismatch!")
+
+            clazz = command.payload[0]
+            try:
+                method = getattr(clazz, command.payload[1])
+            except AttributeError:
+                methods = [method for method in dir(clazz) if callable(getattr(clazz, method))]
+                message = "Method {} not found in class {}. Available methods:\n".format(command.payload[1],
+                                                                                         clazz.__name__)
+                for method in methods:
+                    message += "{}\n".format(method)
+                raise AttributeError(message)
+
+            return method
+        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
+
+

package/Binaries/Python/javonet/core/handler/GetTypeHandler.py

@@ -51,6 +51,7 @@ class GetTypeHandler(AbstractCommandHandler):
             return self._get_type_from_nested_payload(command.payload)
 
     def _get_type_from_nested_payload(self, payload):
-        for i in range(len(payload) - 1):
-            loaded_module = import_module(".".join(payload[:i + 1]))
-        return getattr(loaded_module, payload[-1])
+        module_name = ".".join(payload[:-1])
+        class_name = payload[-1]
+        loaded_module = import_module(module_name)
+        return getattr(loaded_module, class_name)

package/Binaries/Python/javonet/core/handler/Handler.py

@@ -22,6 +22,11 @@ from javonet.core.handler.GetEnumNameHandler import GetEnumNameHandler
 from javonet.core.handler.GetEnumValueHandler import GetEnumValueHandler
 from javonet.core.handler.EnableNamespaceHandler import EnableNamespaceHandler
 from javonet.core.handler.EnableTypeHandler import EnableTypeHandler
+from javonet.core.handler.GetStaticMethodAsDelegateHandler import GetStaticMethodAsDelegateHandler
+from javonet.core.handler.GetInstanceMethodAsDelegateHandler import GetInstanceMethodAsDelegateHandler
+from javonet.core.handler.PassDelegateHandler import PassDelegateHandler
+from javonet.core.handler.InvokeDelegateHandler import InvokeDelegateHandler
+
 
 from javonet.core.handler.HandlerDictionary import handler_dict
 from javonet.core.referenceCache.ReferencesCache import ReferencesCache
@@ -56,6 +61,10 @@ class Handler(AbstractHandler):
         handler_dict[CommandType.GetEnumValue] = GetEnumValueHandler()
         handler_dict[CommandType.EnableNamespace] = EnableNamespaceHandler()
         handler_dict[CommandType.EnableType] = EnableTypeHandler()
+        handler_dict[CommandType.GetStaticMethodAsDelegate] = GetStaticMethodAsDelegateHandler()
+        handler_dict[CommandType.GetInstanceMethodAsDelegate] = GetInstanceMethodAsDelegateHandler()
+        handler_dict[CommandType.PassDelegate] = PassDelegateHandler()
+        handler_dict[CommandType.InvokeDelegate] = InvokeDelegateHandler()
 
     def handle_command(self, command):
         try:

package/Binaries/Python/javonet/core/handler/InvokeDelegateHandler.py

@@ -0,0 +1,27 @@
+from javonet.core.delegateCache.DelegatesCache import DelegatesCache
+from javonet.core.handler.AbstractCommandHandler import *
+
+
+class InvokeDelegateHandler(AbstractCommandHandler):
+
+    def __init__(self):
+        self._required_parameters_count = 1
+
+    def process(self, command):
+        try:
+            if len(command.payload) != self._required_parameters_count:
+                raise Exception("ResolveInstanceHandler parameters mismatch!")
+
+            delegates_cache = DelegatesCache()
+            method = delegates_cache.resolve_delegate(command)
+            if len(command.payload) > 1:
+                method_arguments = command.payload[1:]
+                return method(*method_arguments)
+            else:
+                return method()
+        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
+
+

package/Binaries/Python/javonet/core/handler/InvokeStaticMethodHandler.py

@@ -1,5 +1,3 @@
-import traceback
-
 from javonet.core.handler.AbstractCommandHandler import *
 
 

package/Binaries/Python/javonet/core/handler/PassDelegateHandler.py

@@ -0,0 +1,21 @@
+from javonet.core.delegateCache.DelegatesCache import DelegatesCache
+from javonet.core.handler.AbstractCommandHandler import *
+
+
+class PassDelegateHandler(AbstractCommandHandler):
+
+    def __init__(self):
+        self._required_parameters_count = 1
+
+    def process(self, command):
+        try:
+            if len(command.payload) != self._required_parameters_count:
+                raise Exception("ResolveInstanceHandler parameters mismatch!")
+
+            # 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
+
+

package/Binaries/Python/javonet/core/interpreter/Interpreter.py

@@ -7,7 +7,6 @@ from javonet.utils.connectionData.IConnectionData import IConnectionData
 
 handler = Handler()
 
-
 class Interpreter:
 
     def execute(self, command, connection_data: IConnectionData):

package/Binaries/Python/javonet/core/protocol/CommandDeserializer.py

@@ -6,6 +6,7 @@ from javonet.utils.Type import Type
 from javonet.utils.StringEncodingMode import StringEncodingMode
 
 
+
 class CommandDeserializer:
     position = 0
     buffer = []

package/Binaries/Python/javonet/core/protocol/CommandSerializer.py

@@ -1,6 +1,3 @@
-from collections import deque
-from typing import Deque
-
 from javonet.core.protocol.TypeSerializer import TypeSerializer
 from javonet.utils.Command import Command
 from javonet.utils.RuntimeName import RuntimeName
@@ -8,54 +5,24 @@ from javonet.utils.connectionData.IConnectionData import IConnectionData
 
 
 class CommandSerializer:
-    byte_buffer = []
+    buffer = []
 
     def serialize(self, root_command: Command, connection_data: IConnectionData, runtime_version=0):
-        queue: Deque[Command] = deque()
-        queue.append(root_command)
         self.insert_into_buffer([root_command.runtime_name.value, runtime_version])
         self.insert_into_buffer(connection_data.serialize_connection_data())
         self.insert_into_buffer([RuntimeName.python.value, root_command.command_type.value])
-        return self.serialize_recursively(queue)
-
-    @staticmethod
-    def serialize_primitive(payload_item):
-        if payload_item is None:
-            return TypeSerializer.serialize_none()
-        if isinstance(payload_item, bool):
-            return TypeSerializer.serialize_bool(payload_item)
-        elif isinstance(payload_item, int):
-            if payload_item in range(-2 ** 31, 2 ** 31):
-                return TypeSerializer.serialize_int(payload_item)
-            elif payload_item in range(-2 ** 63, 2 ** 63):
-                return TypeSerializer.serialize_longlong(payload_item)
+        self.serialize_recursively(root_command)
+        return self.buffer
+
+    def serialize_recursively(self, command):
+        for item in command.get_payload():
+            if isinstance(item, Command):
+                self.insert_into_buffer(TypeSerializer.serialize_command(item))
+                self.serialize_recursively(item)
             else:
-                return TypeSerializer.serialize_ullong(payload_item)
-        elif isinstance(payload_item, float):
-            return TypeSerializer.serialize_double(payload_item)
-        elif isinstance(payload_item, str):
-            return TypeSerializer.serialize_string(payload_item)
-        else:
-            raise Exception("Python: Type serialization not supported for type: " + payload_item)
-
-    def insert_into_buffer(self, arguments):
-        self.byte_buffer = self.byte_buffer + arguments
+                self.insert_into_buffer(TypeSerializer.serialize_primitive(item))
 
-    def serialize_recursively(self, queue):
-        if not queue:
-            return self.byte_buffer
-        command = queue.pop()
-        queue.append(command.drop_first_payload_argument())
-        if len(command.get_payload()) > 0:
-            if isinstance(command.get_payload()[0], Command):
-                inner_command = command.get_payload()[0]
-                self.insert_into_buffer(TypeSerializer.serialize_command(inner_command))
-                queue.append(inner_command)
-            else:
-                result = self.serialize_primitive(command.get_payload()[0])
-                self.insert_into_buffer(result)
-            return self.serialize_recursively(queue)
-        else:
-            queue.pop()
+        return
 
-        return self.serialize_recursively(queue)
+    def insert_into_buffer(self, arguments):
+        self.buffer = self.buffer + arguments

package/Binaries/Python/javonet/core/protocol/TypeSerializer.py

@@ -5,7 +5,27 @@ from javonet.utils.StringEncodingMode import StringEncodingMode
 
 
 class TypeSerializer:
-    
+
+    @staticmethod
+    def serialize_primitive(payload_item):
+        if payload_item is None:
+            return TypeSerializer.serialize_none()
+        if isinstance(payload_item, bool):
+            return TypeSerializer.serialize_bool(payload_item)
+        elif isinstance(payload_item, int):
+            if payload_item in range(-2 ** 31, 2 ** 31):
+                return TypeSerializer.serialize_int(payload_item)
+            elif payload_item in range(-2 ** 63, 2 ** 63):
+                return TypeSerializer.serialize_longlong(payload_item)
+            else:
+                return TypeSerializer.serialize_ullong(payload_item)
+        elif isinstance(payload_item, float):
+            return TypeSerializer.serialize_double(payload_item)
+        elif isinstance(payload_item, str):
+            return TypeSerializer.serialize_string(payload_item)
+        else:
+            raise Exception("Python: Type serialization not supported for type: " + payload_item)
+
     @staticmethod
     def serialize_command(command):
         length = list(bytearray(struct.pack("<i", len(command.payload))))

package/Binaries/Python/javonet/core/receiver/Receiver.py

@@ -1,11 +1,16 @@
+import sys
+
 from javonet.core.interpreter.Interpreter import Interpreter
 from javonet.core.protocol.CommandSerializer import CommandSerializer
+from javonet.utils.RuntimeLogger import RuntimeLogger
 from javonet.utils.connectionData.InMemoryConnectionData import InMemoryConnectionData
 
 
 class Receiver:
 
     def __init__(self):
+        RuntimeLogger.print_runtime_info()
+        sys.stdout.flush()
         self.connection_data = InMemoryConnectionData()
 
     def SendCommand(self, message_byte_array, messageByteArrayLen):

package/Binaries/Python/javonet/core/transmitter/TransmitterWrapper.py

@@ -24,6 +24,8 @@ class TransmitterWrapper:
         python_lib_path = file_path + f'/Binaries/Native/Linux/{arch}/libJavonetPythonRuntimeNative.so'
     elif platform.system() == 'Darwin':
         python_lib_path = file_path + f'/Binaries/Native/MacOs/{arch}/libJavonetPythonRuntimeNative.dylib'
+    else:
+        raise RuntimeError("Unsupported OS: " + platform.system())
 
     python_lib = cdll.LoadLibrary(python_lib_path)
     python_lib.SetCallback(callbackFunction)
@@ -69,10 +71,11 @@ class TransmitterWrapper:
             get_native_error.argtypes = []
             error_message = get_native_error()
             raise RuntimeError(
-                "Javonet activation result: " + str(activation_result) + ". Native error message: " + str(error_message))
+                "Javonet activation result: " + str(activation_result) + ". Native error message: " + str(
+                    error_message))
         else:
             return activation_result
-        
+
     @staticmethod
     def set_config_source(sourcePath):
         set_config_source = TransmitterWrapper.python_lib.SetConfigSource
@@ -87,6 +90,7 @@ class TransmitterWrapper:
             get_native_error.argtypes = []
             error_message = get_native_error()
             raise RuntimeError(
-                "Javonet set config source result: " + str(set_config_result) + ". Native error message: " + str(error_message))
+                "Javonet set config source result: " + str(set_config_result) + ". Native error message: " + str(
+                    error_message))
         else:
             return set_config_result

package/Binaries/Python/javonet/utils/CommandType.py

@@ -39,3 +39,7 @@ class CommandType(Enum):
     EnableNamespace = 34
     EnableType = 35
     CreateNull = 36
+    GetStaticMethodAsDelegate = 37
+    GetInstanceMethodAsDelegate = 38
+    PassDelegate = 39
+    InvokeDelegate = 40

package/Binaries/Python/javonet/utils/RuntimeLogger.py

@@ -0,0 +1,30 @@
+import platform
+import os
+import sys
+
+
+class RuntimeLogger:
+
+    not_logged_yet = True
+    @staticmethod
+    def get_runtime_info():
+        try:
+            return (
+                "Python Managed Runtime Info:\n"
+                f"Python Version: {platform.python_version()}\n"
+                f"Python executable path: {sys.executable}\n"
+                f"Python Path: {sys.path}\n"
+                f"Python Implementation: {platform.python_implementation()}\n"
+                f"OS Version: {platform.system()} {platform.version()}\n"
+                f"Process Architecture: {platform.machine()}\n"
+                f"Current Directory: {os.getcwd()}\n"
+            )
+        except Exception as e:
+            return "Python Managed Runtime Info: Error while fetching runtime info"
+
+    @staticmethod
+    def print_runtime_info():
+        if RuntimeLogger.not_logged_yet:
+            print(RuntimeLogger.get_runtime_info())
+            RuntimeLogger.not_logged_yet = False
+