javonet-nodejs-sdk 2.5.13 → 2.5.15

package/Binaries/Python2/javonet/core/referenceCache/ReferencesCache.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+import uuid
+import threading
+from javonet.utils.CommandType import CommandType
+
+
+class ReferencesCache(object):
+    _instance = None
+    references_cache = dict()
+    _lock = threading.Lock()
+
+    def __new__(cls):
+        cls._lock.acquire()
+        try:
+            if cls._instance is None:
+                cls._instance = super(ReferencesCache, cls).__new__(cls)
+        finally:
+            cls._lock.release()
+        return cls._instance
+
+    def cache_reference(self, object_reference):
+        self._lock.acquire()
+        try:
+            uuid_ = str(uuid.uuid4())
+            self.references_cache[uuid_] = object_reference
+            return uuid_
+        finally:
+            self._lock.release()
+
+    def resolve_reference(self, command):
+        try:
+            command_val = command.command_type.value
+            ref_val = CommandType.Reference.value
+        except AttributeError:
+            command_val = command.command_type
+            ref_val = CommandType.Reference
+        if command_val != ref_val:
+            raise Exception("Trying to dereference Python command with command_type: " + str(command.command_type))
+        self._lock.acquire()
+        try:
+            try:
+                return self.references_cache[command.payload[0]]
+            except KeyError:
+                raise Exception("Object not found in references")
+        finally:
+            self._lock.release()
+
+    def delete_reference(self, reference_guid):
+        self._lock.acquire()
+        try:
+            try:
+                del self.references_cache[reference_guid]
+                return 0
+            except KeyError:
+                raise Exception("Object not found in references")
+        finally:
+            self._lock.release()

package/Binaries/Python2/javonet/core/transmitter/Transmitter.py

@@ -0,0 +1,59 @@
+"""
+The Transmitter class serves as a facade for TransmitterWrapper.
+"""
+
+from javonet.core.transmitter.TransmitterWrapper import TransmitterWrapper
+
+
+class Transmitter(object):
+    """
+    Class serving as a facade for TransmitterWrapper.
+    """
+
+    @staticmethod
+    def send_command(message):
+        """
+        Sends a command to the native library.
+
+        :param message: Message to send
+        :return: Response from the native library
+        """
+        return TransmitterWrapper().send_command(message)
+
+    @staticmethod
+    def activate(license_key):
+        """
+        Activates Javonet with the provided license key.
+
+        :param license_key: License key
+        :return: Activation status code
+        """
+        return TransmitterWrapper.activate(license_key)
+
+    @staticmethod
+    def set_config_source(source_path):
+        """
+        Sets the configuration source.
+
+        :param source_path: Path to the configuration source
+        """
+        TransmitterWrapper().set_config_source(source_path)
+
+    @staticmethod
+    def set_working_directory(path):
+        """
+        Sets the working directory.
+
+        :param path: Path to the working directory
+        """
+        TransmitterWrapper().set_working_directory(path)
+
+    @staticmethod
+    def set_javonet_working_directory(path):
+        """
+        Sets the Javonet working directory.
+
+        :param path: Path to the working directory
+        :return: Operation status code
+        """
+        return TransmitterWrapper.set_javonet_working_directory(path) 

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

@@ -0,0 +1,102 @@
+import os
+import platform
+from ctypes import *
+from javonet.core.callback.callbackFunc import callbackFunc
+
+CMPFUNC = CFUNCTYPE(py_object, POINTER(c_ubyte), c_int)
+callbackFunction = CMPFUNC(callbackFunc)
+
+
+class TransmitterWrapper:
+    _python_lib = None
+
+    @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:
+                arch = 'X86'
+
+            system_name = platform.system()
+            if system_name == 'Windows':
+                python_lib_path = file_path + '/Binaries/Native/Windows/{0}/JavonetPython2RuntimeNative.dll'.format(arch)
+            elif system_name == 'Linux':
+                python_lib_path = file_path + '/Binaries/Native/Linux/{0}/libJavonetPython2RuntimeNative.so'.format(arch)
+            elif system_name == 'Darwin':
+                python_lib_path = file_path + '/Binaries/Native/MacOs/{0}/libJavonetPython2RuntimeNative.dylib'.format(arch)
+            else:
+                raise RuntimeError("Unsupported OS: " + system_name)
+            lib = cdll.LoadLibrary(python_lib_path)
+            lib.SetCallback(callbackFunction)
+            TransmitterWrapper._python_lib = lib
+        return TransmitterWrapper._python_lib
+
+    @staticmethod
+    def send_command(message):
+        lib = TransmitterWrapper.get_native_lib()
+        message_array = bytearray(message)
+        message_ubyte_array = (c_ubyte * len(message_array))
+        response_array_len = lib.SendCommand(message_ubyte_array.from_buffer(message_array), len(message_array))
+        if response_array_len > 0:
+            response = bytearray(response_array_len)
+            response_ubyte_array = (c_ubyte * response_array_len)
+            lib.ReadResponse(response_ubyte_array.from_buffer(response), response_array_len)
+            return response
+        elif response_array_len == 0:
+            raise RuntimeError("Response is empty")
+        else:
+            lib.GetNativeError.restype = c_char_p
+            lib.GetNativeError.argtypes = []
+            error_message = lib.GetNativeError()
+            raise RuntimeError("Javonet native error code: {0}. {1}".format(response_array_len, error_message))
+
+    @staticmethod
+    def activate(license_key):
+        lib = TransmitterWrapper.get_native_lib()
+        activate_func = lib.Activate
+        activate_func.restype = c_int
+        activate_func.argtypes = [c_char_p]
+        # In Python 2, you can still use encode() to ensure a byte string.
+        activation_result = activate_func(license_key.encode('ascii'))
+        if activation_result < 0:
+            lib.GetNativeError.restype = c_char_p
+            lib.GetNativeError.argtypes = []
+            error_message = lib.GetNativeError()
+            raise RuntimeError("Javonet activation result: {0}. Native error message: {1}".format(activation_result, error_message))
+        else:
+            return activation_result
+
+    @staticmethod
+    def set_config_source(source_path):
+        lib = TransmitterWrapper.get_native_lib()
+        set_config_source_func = lib.SetConfigSource
+        set_config_source_func.restype = c_int
+        set_config_source_func.argtypes = [c_char_p]
+        set_config_result = set_config_source_func(source_path.encode('utf-8'))
+        if set_config_result < 0:
+            lib.GetNativeError.restype = c_char_p
+            lib.GetNativeError.argtypes = []
+            error_message = lib.GetNativeError()
+            raise RuntimeError("Javonet set config source result: {0}. Native error message: {1}".format(set_config_result, error_message))
+        else:
+            return set_config_result
+
+    @staticmethod
+    def set_javonet_working_directory(path):
+        lib = TransmitterWrapper.get_native_lib()
+        set_working_directory_func = lib.SetWorkingDirectory
+        set_working_directory_func.restype = c_int
+        set_working_directory_func.argtypes = [c_char_p]
+        set_working_directory_result = set_working_directory_func(path.encode('utf-8'))
+        if set_working_directory_result < 0:
+            lib.GetNativeError.restype = c_char_p
+            lib.GetNativeError.argtypes = []
+            error_message = lib.GetNativeError()
+            raise RuntimeError("Javonet set working directory result: {0}. Native error message: {1}".format(set_working_directory_result, error_message))
+        else:
+            return set_working_directory_result

package/Binaries/Python2/javonet/core/typeCache/TypeCache.py

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+import re
+import types
+import threading
+
+
+class TypeCache(object):
+    _instance = None
+    type_cache = list()
+    _lock = threading.Lock()
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._lock.acquire()
+            try:
+                if cls._instance is None:
+                    cls._instance = super(TypeCache, cls).__new__(cls)
+            finally:
+                cls._lock.release()
+        return cls._instance
+
+    def cache_type(self, type_name):
+        """
+        Cache a type.
+        
+        :param type_name: Type name to cache
+        """
+        with self._lock:
+            # Handle Python 2.7 vs Python 3 module name differences
+            if type_name.startswith("builtins"):
+                type_name = type_name.replace("builtins", "__builtin__", 1)
+            
+            self.type_cache.append(type_name)
+
+    def is_type_cache_empty(self):
+        self._lock.acquire()
+        try:
+            return len(self.type_cache) == 0
+        finally:
+            self._lock.release()
+
+    def is_type_allowed(self, type_to_check):
+        self._lock.acquire()
+        try:
+            if isinstance(type_to_check, types.ModuleType):
+                name_to_check = type_to_check.__name__
+            else:
+                name_to_check = ".".join([type_to_check.__module__, type_to_check.__name__])
+            for pattern in self.type_cache:
+                if re.match(pattern, name_to_check):
+                    return True
+            return False
+        finally:
+            self._lock.release()
+
+    def get_cached_types(self):
+        self._lock.acquire()
+        try:
+            return self.type_cache[:]
+        finally:
+            self._lock.release()
+
+    def clear_cache(self):
+        self._lock.acquire()
+        try:
+            del self.type_cache[:]
+            return 0
+        finally:
+            self._lock.release()

package/Binaries/Python2/javonet/core/typeCache/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""
+The typeCache package contains type caching implementation.
+"""

package/Binaries/Python2/javonet/core/webSocketClient/WebSocketClient.py

@@ -0,0 +1,39 @@
+"""
+The WebSocketClient module implements a WebSocket client.
+"""
+
+import struct
+from websockets.sync.client import connect
+
+from javonet.utils.connectionData.WsConnectionData import WsConnectionData
+
+
+class WebSocketClient(object):
+    """
+    Class implementing a WebSocket client.
+    """
+
+    def send_message(self, connection_data, serialized_command):
+        """
+        Sends a message through WebSocket.
+
+        :param connection_data: Connection data
+        :param serialized_command: Serialized command
+        :return: Server response
+        """
+        byte_array = struct.pack("B" * len(serialized_command), *serialized_command)
+        return self.send(connection_data, byte_array)
+
+    def send(self, connection_data, byte_array):
+        """
+        Sends data through WebSocket.
+
+        :param connection_data: Connection data
+        :param byte_array: Byte array to send
+        :return: Server response
+        """
+        websocket = connect(connection_data.hostname)
+        websocket.send(byte_array)
+        response = websocket.recv()
+        websocket.close()
+        return response 

package/Binaries/Python2/javonet/utils/Command.py

@@ -0,0 +1,170 @@
+# -*- coding: utf-8 -*-
+"""
+The Command class represents a command sent to the Javonet runtime environment.
+"""
+
+from javonet.utils.CommandType import CommandType
+
+
+class Command(object):
+
+    def __init__(self, runtime_name, command_type, payload):
+        """
+        Initializes a new command.
+
+        :param runtime_name: Runtime environment name
+        :param command_type: Command type
+        :param payload: Command payload
+        """
+        self.runtime_name = runtime_name
+        self.command_type = command_type
+        self.payload = payload
+
+    def get_payload(self):
+        """
+        Returns the command payload.
+
+        :return: Command payload
+        """
+        return self.payload
+
+    @staticmethod
+    def create_response(response, runtime_name):
+        """
+        Creates a response command.
+
+        :param response: Response
+        :param runtime_name: Runtime environment name
+        :return: New response command
+        """
+        return Command(runtime_name, CommandType.Value, [response])
+
+    @staticmethod
+    def create_reference(guid, runtime_name):
+        """
+        Creates a reference command.
+
+        :param guid: GUID identifier
+        :param runtime_name: Runtime environment name
+        :return: New reference command
+        """
+        return Command(runtime_name, CommandType.Reference, [guid])
+
+    @staticmethod
+    def create_array_response(array, runtime_name):
+        """
+        Creates an array response command.
+
+        :param array: Array
+        :param runtime_name: Runtime environment name
+        :return: New array response command
+        """
+        return Command(runtime_name, CommandType.Array, array)
+
+    def drop_first_payload_argument(self):
+        """
+        Removes the first argument from the payload.
+
+        :return: New command without the first argument
+        """
+        payload_args = []
+        payload_args.extend(self.payload)
+        if len(payload_args) != 0:
+            payload_args.pop(0)
+        return Command(self.runtime_name, self.command_type, payload_args)
+
+    def add_arg_to_payload(self, argument):
+        """
+        Adds an argument to the payload.
+
+        :param argument: Argument to add
+        :return: New command with the added argument
+        """
+        merged_payload = self.payload + [argument]
+        return Command(self.runtime_name, self.command_type, merged_payload)
+
+    def prepend_arg_to_payload(self, current_command):
+        """
+        Adds an argument to the beginning of the payload.
+
+        :param current_command: Current command
+        :return: New command with the argument added at the beginning
+        """
+        if current_command is None:
+            return Command(self.runtime_name, self.command_type, self.payload)
+        else:
+            return Command(self.runtime_name, self.command_type, [current_command] + self.payload)
+
+    def to_string(self):
+        """
+        Returns a text representation of the command.
+
+        :return: Text representation of the command
+        """
+        return 'Target runtime: ' + str(self.runtime_name) + ' Command type: ' + str(
+            self.command_type) + ' Payload: ' + str(self.payload)
+
+    def __eq__(self, other):
+        """
+        Compare this command with another element.
+        
+        :param other: Element to compare with
+        :return: True if equal, False otherwise
+        """
+        # Basic comparison
+        if not isinstance(other, self.__class__):
+            return False
+        
+        # Compare command_type and runtime_name as numeric values
+        if hasattr(self.command_type, 'value') and hasattr(other.command_type, 'value'):
+            if self.command_type.value != other.command_type.value:
+                return False
+        else:
+            # If they don't have value attribute, compare directly
+            if self.command_type != other.command_type:
+                return False
+            
+        if hasattr(self.runtime_name, 'value') and hasattr(other.runtime_name, 'value'):
+            if self.runtime_name.value != other.runtime_name.value:
+                return False
+        else:
+            if self.runtime_name != other.runtime_name:
+                return False
+        
+        # Compare payload length
+        if len(self.payload) != len(other.payload):
+            return False
+        
+        # Compare each payload item
+        for i in range(len(self.payload)):
+            # For simple types
+            if self.payload[i] != other.payload[i]:
+                return False
+                
+        return True
+
+    def __str__(self):
+        """
+        String representation of the command.
+        
+        :return: String representation
+        """
+        return "Command(type={0}, runtime={1}, payload_len={2})".format(
+            self.command_type, self.runtime_name, len(self.payload))
+        
+    def __repr__(self):
+        """
+        Detailed representation of the command.
+        
+        :return: Detailed representation
+        """
+        return self.__str__()
+
+    def __ne__(self, element):
+        """
+        Compare this command with another element for inequality.
+        
+        :param element: Element to compare with
+        :return: True if not equal, False otherwise
+        """
+        return not self.__eq__(element)

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

@@ -0,0 +1,154 @@
+"""
+The CommandType class represents command types used in communication with Javonet.
+"""
+
+# Python 2 doesn't have an enum module, so we implement our own version
+class CommandType(object):
+    def __init__(self, value):
+        self.value = value
+
+    def __eq__(self, other):
+        if isinstance(other, CommandType):
+            return self.value == other.value
+        return False
+
+    def __hash__(self):
+        return hash(self.value)
+
+    def __str__(self):
+        return self._name_map.get(self.value, str(self.value))
+
+    def __repr__(self):
+        return "CommandType." + str(self)
+
+    Value = None  # These values will be set below
+    LoadLibrary = None
+    InvokeStaticMethod = None
+    GetStaticField = None
+    SetStaticField = None
+    CreateClassInstance = None
+    GetType = None
+    Reference = None
+    GetModule = None
+    InvokeInstanceMethod = None
+    Exception = None
+    HeartBeat = None
+    Cast = None
+    GetInstanceField = None
+    Optimize = None
+    GenerateLib = None
+    InvokeGlobalFunction = None
+    DestructReference = None
+    ArrayReference = None
+    ArrayGetItem = None
+    ArrayGetSize = None
+    ArrayGetRank = None
+    ArraySetItem = None
+    Array = None
+    RetrieveArray = None
+    SetInstanceField = None
+    InvokeGenericStaticMethod = None
+    InvokeGenericMethod = None
+    GetEnumItem = None
+    GetEnumName = None
+    GetEnumValue = None
+    AsRef = None
+    AsOut = None
+    GetRefValue = None
+    EnableNamespace = None
+    EnableType = None
+    CreateNull = None
+    GetStaticMethodAsDelegate = None
+    GetInstanceMethodAsDelegate = None
+    PassDelegate = None
+    InvokeDelegate = None
+    ConvertType = None
+
+    _name_map = {
+        0: 'Value',
+        1: 'LoadLibrary',
+        2: 'InvokeStaticMethod',
+        3: 'GetStaticField',
+        4: 'SetStaticField',
+        5: 'CreateClassInstance',
+        6: 'GetType',
+        7: 'Reference',
+        8: 'GetModule',
+        9: 'InvokeInstanceMethod',
+        10: 'Exception',
+        11: 'HeartBeat',
+        12: 'Cast',
+        13: 'GetInstanceField',
+        14: 'Optimize',
+        15: 'GenerateLib',
+        16: 'InvokeGlobalFunction',
+        17: 'DestructReference',
+        18: 'ArrayReference',
+        19: 'ArrayGetItem',
+        20: 'ArrayGetSize',
+        21: 'ArrayGetRank',
+        22: 'ArraySetItem',
+        23: 'Array',
+        24: 'RetrieveArray',
+        25: 'SetInstanceField',
+        26: 'InvokeGenericStaticMethod',
+        27: 'InvokeGenericMethod',
+        28: 'GetEnumItem',
+        29: 'GetEnumName',
+        30: 'GetEnumValue',
+        31: 'AsRef',
+        32: 'AsOut',
+        33: 'GetRefValue',
+        34: 'EnableNamespace',
+        35: 'EnableType',
+        36: 'CreateNull',
+        37: 'GetStaticMethodAsDelegate',
+        38: 'GetInstanceMethodAsDelegate',
+        39: 'PassDelegate',
+        40: 'InvokeDelegate',
+        41: 'ConvertType'
+    }
+
+# Initialize values
+CommandType.Value = CommandType(0)
+CommandType.LoadLibrary = CommandType(1)
+CommandType.InvokeStaticMethod = CommandType(2)
+CommandType.GetStaticField = CommandType(3)
+CommandType.SetStaticField = CommandType(4)
+CommandType.CreateClassInstance = CommandType(5)
+CommandType.GetType = CommandType(6)
+CommandType.Reference = CommandType(7)
+CommandType.GetModule = CommandType(8)
+CommandType.InvokeInstanceMethod = CommandType(9)
+CommandType.Exception = CommandType(10)
+CommandType.HeartBeat = CommandType(11)
+CommandType.Cast = CommandType(12)
+CommandType.GetInstanceField = CommandType(13)
+CommandType.Optimize = CommandType(14)
+CommandType.GenerateLib = CommandType(15)
+CommandType.InvokeGlobalFunction = CommandType(16)
+CommandType.DestructReference = CommandType(17)
+CommandType.ArrayReference = CommandType(18)
+CommandType.ArrayGetItem = CommandType(19)
+CommandType.ArrayGetSize = CommandType(20)
+CommandType.ArrayGetRank = CommandType(21)
+CommandType.ArraySetItem = CommandType(22)
+CommandType.Array = CommandType(23)
+CommandType.RetrieveArray = CommandType(24)
+CommandType.SetInstanceField = CommandType(25)
+CommandType.InvokeGenericStaticMethod = CommandType(26)
+CommandType.InvokeGenericMethod = CommandType(27)
+CommandType.GetEnumItem = CommandType(28)
+CommandType.GetEnumName = CommandType(29)
+CommandType.GetEnumValue = CommandType(30)
+CommandType.AsRef = CommandType(31)
+CommandType.AsOut = CommandType(32)
+CommandType.GetRefValue = CommandType(33)
+CommandType.EnableNamespace = CommandType(34)
+CommandType.EnableType = CommandType(35)
+CommandType.CreateNull = CommandType(36)
+CommandType.GetStaticMethodAsDelegate = CommandType(37)
+CommandType.GetInstanceMethodAsDelegate = CommandType(38)
+CommandType.PassDelegate = CommandType(39)
+CommandType.InvokeDelegate = CommandType(40)
+CommandType.ConvertType = CommandType(41) 

package/Binaries/Python2/javonet/utils/ConnectionType.py

@@ -0,0 +1,36 @@
+"""
+Connection type with the runtime.
+"""
+
+class ConnectionType(object):
+    def __init__(self, value):
+        self.value = value
+
+    def __eq__(self, other):
+        if isinstance(other, ConnectionType):
+            return self.value == other.value
+        return False
+
+    def __hash__(self):
+        return hash(self.value)
+
+    def __str__(self):
+        return self._name_map.get(self.value, str(self.value))
+
+    def __repr__(self):
+        return "ConnectionType." + str(self)
+
+    InMemory = None
+    Tcp = None
+    WebSocket = None
+
+    _name_map = {
+        0: 'InMemory',
+        1: 'Tcp',
+        2: 'WebSocket'
+    }
+
+# Initialize values
+ConnectionType.InMemory = ConnectionType(0)
+ConnectionType.Tcp = ConnectionType(1)
+ConnectionType.WebSocket = ConnectionType(2)