javonet-nodejs-sdk 2.4.10 → 2.5.0

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

@@ -1,56 +0,0 @@
-from importlib import import_module
-
-from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
-from javonet.core.namespaceCache.NamespaceCache import NamespaceCache
-from javonet.core.typeCache.TypeCache import TypeCache
-
-
-class GetTypeHandler(AbstractCommandHandler):
-    def __init__(self):
-        self._required_parameters_count = 1
-        self.namespace_cache = NamespaceCache()
-        self.type_cache = TypeCache()
-
-    def process(self, command):
-        try:
-            if len(command.payload) < self._required_parameters_count:
-                raise Exception(self.__class__.__name__ + " parameters mismatch!")
-
-            type_to_return = self._get_type_from_payload(command)
-
-            if type_to_return is None:
-                raise Exception(f"Type {command.payload[0]} not found")
-
-            if ((
-                    self.namespace_cache.is_namespace_cache_empty() and self.type_cache.is_type_cache_empty()) or  # both caches are empty
-                    self.namespace_cache.is_type_allowed(type_to_return) or  # namespace is allowed
-                    self.type_cache.is_type_allowed(type_to_return)  # type is allowed
-            ):
-                pass  # continue - type is allowed
-            else:
-                allowed_namespaces = ", ".join(self.namespace_cache.get_cached_namespaces())
-                allowed_types = ", ".join(self.type_cache.get_cached_types())
-                raise Exception(
-                    f"Type {type_to_return.__name__} not allowed. \nAllowed namespaces: {allowed_namespaces}\nAllowed types: {allowed_types}")
-
-            return type_to_return
-
-        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
-
-    def _get_type_from_payload(self, command):
-        if len(command.payload) == 1:
-            type_name = command.payload[0].split(".")
-            if len(type_name) == 1:
-                return import_module(type_name[0])
-            else:
-                return self._get_type_from_nested_payload(type_name)
-        else:
-            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])

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

@@ -1,89 +0,0 @@
-from javonet.core.handler.AbstractHandler import AbstractHandler
-from javonet.core.handler.ValueHandler import ValueHandler
-from javonet.core.handler.LoadLibraryHandler import LoadLibraryHandler
-from javonet.core.handler.InvokeStaticMethodHandler import InvokeStaticMethodHandler
-from javonet.core.handler.SetStaticFieldHandler import SetStaticFieldHandler
-from javonet.core.handler.CreateClassInstanceHandler import CreateClassInstanceHandler
-from javonet.core.handler.GetStaticFieldHandler import GetStaticFieldHandler
-from javonet.core.handler.ResolveInstanceHandler import ResolveInstanceHandler
-from javonet.core.handler.GetTypeHandler import GetTypeHandler
-from javonet.core.handler.InvokeInstanceMethodHandler import InvokeInstanceMethodHandler
-from javonet.core.handler.CastingHandler import CastingHandler
-from javonet.core.handler.GetInstanceFieldHandler import GetInstanceFieldHandler
-from javonet.core.handler.SetInstanceFieldHandler import SetInstanceFieldHandler
-from javonet.core.handler.DestructReferenceHandler import DestructReferenceHandler
-from javonet.core.handler.ArrayGetItemHandler import ArrayGetItemHandler
-from javonet.core.handler.ArrayGetSizeHandler import ArrayGetSizeHandler
-from javonet.core.handler.ArrayGetRankHandler import ArrayGetRankHandler
-from javonet.core.handler.ArraySetItemHandler import ArraySetItemHandler
-from javonet.core.handler.ArrayHandler import ArrayHandler
-from javonet.core.handler.GetEnumItemHandler import GetEnumItemHandler
-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.HandlerDictionary import handler_dict
-from javonet.core.referenceCache.ReferencesCache import ReferencesCache
-from javonet.utils.exception.ExceptionSerializer import ExceptionSerializer
-from javonet.utils.CommandType import CommandType
-from javonet.utils.Command import Command
-
-
-class Handler(AbstractHandler):
-
-    def __init__(self):
-        handler_dict[CommandType.Value] = ValueHandler()
-        handler_dict[CommandType.LoadLibrary] = LoadLibraryHandler()
-        handler_dict[CommandType.InvokeStaticMethod] = InvokeStaticMethodHandler()
-        handler_dict[CommandType.SetStaticField] = SetStaticFieldHandler()
-        handler_dict[CommandType.CreateClassInstance] = CreateClassInstanceHandler()
-        handler_dict[CommandType.GetStaticField] = GetStaticFieldHandler()
-        handler_dict[CommandType.Reference] = ResolveInstanceHandler()
-        handler_dict[CommandType.GetType] = GetTypeHandler()
-        handler_dict[CommandType.InvokeInstanceMethod] = InvokeInstanceMethodHandler()
-        handler_dict[CommandType.Cast] = CastingHandler()
-        handler_dict[CommandType.GetInstanceField] = GetInstanceFieldHandler()
-        handler_dict[CommandType.SetInstanceField] = SetInstanceFieldHandler()
-        handler_dict[CommandType.DestructReference] = DestructReferenceHandler()
-        handler_dict[CommandType.ArrayGetItem] = ArrayGetItemHandler()
-        handler_dict[CommandType.ArrayGetSize] = ArrayGetSizeHandler()
-        handler_dict[CommandType.ArrayGetRank] = ArrayGetRankHandler()
-        handler_dict[CommandType.ArraySetItem] = ArraySetItemHandler()
-        handler_dict[CommandType.Array] = ArrayHandler()
-        handler_dict[CommandType.GetEnumItem] = GetEnumItemHandler()
-        handler_dict[CommandType.GetEnumName] = GetEnumNameHandler()
-        handler_dict[CommandType.GetEnumValue] = GetEnumValueHandler()
-        handler_dict[CommandType.EnableNamespace] = EnableNamespaceHandler()
-        handler_dict[CommandType.EnableType] = EnableTypeHandler()
-
-    def handle_command(self, command):
-        try:
-            if command.command_type == CommandType.RetrieveArray:
-                response_array = handler_dict[CommandType.Reference].handle_command(command.payload[0])
-                return Command.create_array_response(response_array, command.runtime_name)
-
-            response = handler_dict.get(command.command_type).handle_command(command)
-            return self.__parse_response(response, command.runtime_name)
-        except Exception as e:
-            return ExceptionSerializer.serialize_exception(e, command)
-
-    def __parse_response(self, response, runtime_name):
-        if self.__is_response_simple_type(response) or self.__is_response_null(response):
-            return Command.create_response(response, runtime_name)
-        else:
-            reference_cache = ReferencesCache()
-            guid = reference_cache.cache_reference(response)
-            return Command.create_reference(guid, runtime_name)
-
-    @staticmethod
-    def __is_response_simple_type(response):
-        return isinstance(response, (int, float, bool, str))
-
-    @staticmethod
-    def __is_response_null(response):
-        return response is None
-
-    @staticmethod
-    def __is_response_array(response):
-        return isinstance(response, list);

package/Binaries/Python/Windows/X64/javonet/core/handler/HandlerDictionary.py

@@ -1,8 +0,0 @@
-handler_dict = {}
-
-
-class HandlerDictionary:
-
-    @staticmethod
-    def add_handler_to_dict(command_type, handler):
-        handler_dict[command_type] = handler

package/Binaries/Python/Windows/X64/javonet/core/handler/InvokeInstanceMethodHandler.py

@@ -1,31 +0,0 @@
-from javonet.core.handler.AbstractCommandHandler import *
-
-
-class InvokeInstanceMethodHandler(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)
-            
-            if len(command.payload) > 2:
-                method_arguments = command.payload[2:]
-                return method(*method_arguments)
-            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/Windows/X64/javonet/core/handler/InvokeStaticMethodHandler.py

@@ -1,35 +0,0 @@
-import traceback
-
-from javonet.core.handler.AbstractCommandHandler import *
-
-
-class InvokeStaticMethodHandler(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)
-            
-            if len(command.payload) > 2:
-                method_arguments = command.payload[2:]
-                return method(*method_arguments)
-            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/Windows/X64/javonet/core/handler/LoadLibraryHandler.py

@@ -1,25 +0,0 @@
-from javonet.core.handler.AbstractCommandHandler import *
-import sys
-import os
-
-
-class LoadLibraryHandler(AbstractCommandHandler):
-
-    def __init__(self):
-        self._required_parameters_count = 1
-
-    def process(self, command):
-        try:
-            if len(command.payload) != self._required_parameters_count:
-                raise Exception("LoadLibrary payload parameters mismatch")
-
-            if os.path.isdir(command.payload[0]):
-                sys.path.append(command.payload[0])
-            else:
-                raise Exception(command.payload[0] + " does not exist");
-
-            return 0
-        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/Windows/X64/javonet/core/handler/ResolveInstanceHandler.py

@@ -1,19 +0,0 @@
-from javonet.core.handler.AbstractCommandHandler import *
-from javonet.core.referenceCache.ReferencesCache import ReferencesCache
-
-
-class ResolveInstanceHandler(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!")
-
-            references_cache = ReferencesCache()
-            return references_cache.resolve_reference(command)
-        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/Windows/X64/javonet/core/handler/SetInstanceFieldHandler.py

@@ -1,29 +0,0 @@
-from javonet.core.handler.AbstractCommandHandler import *
-
-
-class SetInstanceFieldHandler(AbstractCommandHandler):
-
-    def __init__(self):
-        self._required_parameters_count = 3
-
-    def process(self, command):
-        try:
-            if len(command.payload) < self._required_parameters_count:
-                raise Exception("SetInstanceFieldHandler parameters mismatch!")
-            instance = command.payload[0]
-            field = command.payload[1]
-            new_value = command.payload[2]
-            try:
-                setattr(instance, field, new_value)
-            except AttributeError:
-                fields = [field for field in dir(instance) if not callable(getattr(instance, field))]
-                message = "Field {} not found in class {}. Available fields:\n".format(field, instance.__class__.__name__)
-                for field in fields:
-                    message += "{}\n".format(field)
-                raise AttributeError(message)
-            return 0
-        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/Windows/X64/javonet/core/handler/SetStaticFieldHandler.py

@@ -1,29 +0,0 @@
-from javonet.core.handler.AbstractCommandHandler import *
-
-
-class SetStaticFieldHandler(AbstractCommandHandler):
-
-    def __init__(self):
-        self._required_parameters_count = 3
-
-    def process(self, command):
-        try:
-            if len(command.payload) != self._required_parameters_count:
-                raise Exception("SetStaticFieldHandler parameters mismatch!")
-
-            clazz = command.payload[0]
-            field = command.payload[1]
-            new_value = command.payload[2]
-            try:
-                setattr(clazz, field, new_value)
-            except AttributeError:
-                fields = [field for field in dir(clazz) if not callable(getattr(clazz, field))]
-                message = "Field {} not found in class {}. Available fields:\n".format(field, clazz.__name__)
-                for field in fields:
-                    message += "{}\n".format(field)
-                raise AttributeError(message)
-            return 0
-        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/Windows/X64/javonet/core/handler/ValueHandler.py

@@ -1,6 +0,0 @@
-from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
-
-
-class ValueHandler(AbstractCommandHandler):
-    def process(self, command):
-        return command.payload[0]

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

@@ -1,34 +0,0 @@
-from javonet.core.handler.Handler import Handler
-from javonet.core.protocol.CommandDeserializer import CommandDeserializer
-from javonet.core.protocol.CommandSerializer import CommandSerializer
-from javonet.utils.ConnectionType import ConnectionType
-from javonet.utils.RuntimeName import RuntimeName
-from javonet.utils.connectionData.IConnectionData import IConnectionData
-
-class Interpreter:
-
-    def execute(self, command, connection_data: IConnectionData):
-        command_serializer = CommandSerializer()
-        serialized_command = command_serializer.serialize(command, connection_data)
-        response = None
-        if connection_data.connection_type == ConnectionType.WebSocket:
-            from javonet.core.webSocketClient.WebSocketClient import WebSocketClient
-            response = WebSocketClient().send_message(connection_data, serialized_command)
-        elif (command.runtime_name == RuntimeName.python) & (connection_data.connection_type == ConnectionType.InMemory):
-            from javonet.core.receiver.Receiver import Receiver
-            response = Receiver().SendCommand(serialized_command, len(serialized_command))
-        else:
-            from javonet.core.transmitter.Transmitter import Transmitter
-            response = Transmitter.send_command(serialized_command)
-
-        command_deserializer = CommandDeserializer(response, len(response))
-        return command_deserializer.deserialize()
-
-    def process(self, byte_array, byte_array_len, connection_data: IConnectionData):
-        command_deserializer = CommandDeserializer(byte_array, byte_array_len)
-        received_command = command_deserializer.deserialize()
-        python_handler = Handler()
-        command_serializer = CommandSerializer()
-        response_command = python_handler.handle_command(received_command)
-        encoded_response = command_serializer.serialize(response_command, connection_data)
-        return encoded_response

package/Binaries/Python/Windows/X64/javonet/core/namespaceCache/NamespaceCache.py

@@ -1,44 +0,0 @@
-import re
-import types
-import threading
-
-
-class NamespaceCache(object):
-    _instance = None
-    namespace_cache = list()
-    _lock = threading.Lock()
-
-    def __new__(cls):
-        if cls._instance is None:
-            with cls._lock:
-                if cls._instance is None:
-                    cls._instance = super(NamespaceCache, cls).__new__(cls)
-        return cls._instance
-
-    def cache_namespace(self, namespace_regex):
-        with self._lock:
-            self.namespace_cache.append(namespace_regex)
-
-    def is_namespace_cache_empty(self):
-        with self._lock:
-            return len(self.namespace_cache) == 0
-
-    def is_type_allowed(self, type_to_check):
-        with self._lock:
-            for pattern in self.namespace_cache:
-                if isinstance(type_to_check, types.ModuleType):
-                    if re.match(pattern, type_to_check.__name__):
-                        return True
-                else:
-                    if re.match(pattern, type_to_check.__module__):
-                        return True
-        return False
-
-    def get_cached_namespaces(self):
-        with self._lock:
-            return self.namespace_cache[:]
-
-    def clear_cache(self):
-        with self._lock:
-            self.namespace_cache.clear()
-            return 0

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

@@ -1,147 +0,0 @@
-from javonet.core.protocol.TypeDeserializer import TypeDeserializer
-from javonet.utils.Command import Command
-from javonet.utils.CommandType import CommandType
-from javonet.utils.RuntimeName import RuntimeName
-from javonet.utils.Type import Type
-from javonet.utils.StringEncodingMode import StringEncodingMode
-
-
-class CommandDeserializer:
-    position = 0
-    buffer = []
-    command = 0
-    buffer_len = 0
-
-    def __init__(self, buffer, buffer_len):
-        self.buffer = buffer
-        self.buffer_len = buffer_len
-        self.command = Command(RuntimeName(buffer[0]), CommandType(buffer[10]), [])
-        self.position = 11
-
-    def is_at_end(self):
-        return self.position == self.buffer_len
-
-    def deserialize(self):
-        while not self.is_at_end():
-            self.command = self.command.add_arg_to_payload(self.read_object(self.buffer[self.position]))
-        return self.command
-
-    # def copy_from(self, bytes_to_copy, elements_to_skip):
-    #     size = len(bytes_to_copy) - elements_to_skip
-    #     new_byte_array = bytes_to_copy[size:]
-    #     return new_byte_array
-
-    def read_object(self, type_num):
-        type_value = Type(type_num)
-        switch = {
-            Type.Command: self.read_command,
-            Type.JavonetString: self.read_string,
-            Type.JavonetInteger: self.read_int,
-            Type.JavonetBoolean: self.read_bool,
-            Type.JavonetFloat: self.read_float,
-            Type.JavonetByte: self.read_byte,
-            Type.JavonetChar: self.read_char,
-            Type.JavonetLongLong: self.read_longlong,
-            Type.JavonetDouble: self.read_double,
-            Type.JavonetUnsignedLongLong: self.read_ullong,
-            Type.JavonetUnsignedInteger: self.read_uint,
-            Type.JavonetNoneType: self.read_none
-        }
-        return switch.get(type_value, lambda: Exception("Type not supported"))()
-
-    def read_command(self):
-        p = self.position
-        number_of_elements_in_payload = TypeDeserializer.deserialize_int(self.buffer[p + 1: p + 5])
-        runtime = self.buffer[p + 5]
-        command_type = self.buffer[p + 6]
-        self.position += 7
-        return_command = Command(RuntimeName(runtime), CommandType(command_type), [])
-        return self.read_command_recursively(number_of_elements_in_payload, return_command)
-
-    def read_command_recursively(self, number_of_elements_in_payload_left, cmd):
-        if number_of_elements_in_payload_left == 0:
-            return cmd
-        else:
-            p = self.position
-            cmd = cmd.add_arg_to_payload(self.read_object(self.buffer[p]))
-            return self.read_command_recursively(number_of_elements_in_payload_left - 1, cmd)
-
-    def read_string(self):
-        p = self.position
-        string_encoding_mode = StringEncodingMode(self.buffer[p+1])
-        size = TypeDeserializer.deserialize_int(self.buffer[p + 2:p + 6])
-        self.position += 6
-        p = self.position
-        self.position += size
-        return TypeDeserializer.deserialize_string(string_encoding_mode, self.buffer[p:p + size])
-
-    def read_int(self):
-        size = 4
-        self.position += 2
-        p = self.position
-        self.position += size
-        return TypeDeserializer.deserialize_int(self.buffer[p:p + size])
-
-    def read_bool(self):
-        size = 1
-        self.position += 2
-        p = self.position
-        self.position += size
-        return TypeDeserializer.deserialize_bool(self.buffer[p:p+size])
-
-    def read_float(self):
-        size = 4
-        self.position += 2
-        p = self.position
-        self.position += size
-        return TypeDeserializer.deserialize_float(self.buffer[p:p + size])
-    
-    def read_byte(self):
-        size = 1
-        self.position += 2
-        p = self.position
-        self.position += size
-        return TypeDeserializer.deserialize_byte(self.buffer[p:p+size])
-    
-    def read_char(self):
-        size = 1
-        self.position += 2
-        p = self.position
-        self.position += size
-        return TypeDeserializer.deserialize_char(self.buffer[p:p+size])
-
-    def read_longlong(self):
-        size = 8
-        self.position += 2
-        p = self.position
-        self.position += size
-        return TypeDeserializer.deserialize_longlong(self.buffer[p:p + size])
-
-    def read_double(self):
-        size = 8
-        self.position += 2
-        p = self.position
-        self.position += size
-        return TypeDeserializer.deserialize_double(self.buffer[p:p + size])
-
-    def read_ullong(self):
-        size = 8
-        self.position += 2
-        p = self.position
-        self.position += size
-        return TypeDeserializer.deserialize_ullong(self.buffer[p:p + size])
-
-    def read_uint(self):
-        size = 4
-        self.position += 2
-        p = self.position
-        self.position += size
-        return TypeDeserializer.deserialize_uint(self.buffer[p:p + size])
-
-    def read_none(self):
-        size = 1
-        self.position += 2
-        p = self.position
-        self.position += size
-        return TypeDeserializer.deserialize_none(self.buffer[p:p + size])
-