javonet-ruby-sdk 2.5.12 → 2.5.14

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/core/interpreter/Interpreter.py

@@ -1,16 +1,25 @@
+import os
 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
+from javonet.utils.messageHelper.MessageHelper import MessageHelper
 
 handler = Handler()
 
+
 class Interpreter:
+    debug_mode = os.environ.get("JAVONET_DEBUG") == "TRUE"
 
     def execute(self, command, connection_data: IConnectionData):
+        if self.debug_mode:
+            print("Sent command: " + str(command))
+            MessageHelper.send_message_to_app_insights("SentCommand", str(command))
+
         message_byte_array = CommandSerializer().serialize(command, connection_data)
+
         if connection_data.connection_type == ConnectionType.WebSocket:
             from javonet.core.webSocketClient.WebSocketClient import WebSocketClient
             response_byte_array = WebSocketClient().send_message(connection_data, message_byte_array)
@@ -22,8 +31,25 @@ class Interpreter:
             from javonet.core.transmitter.Transmitter import Transmitter
             response_byte_array = Transmitter.send_command(message_byte_array)
 
-        return CommandDeserializer(response_byte_array).deserialize()
+        response = CommandDeserializer(response_byte_array).deserialize()
+
+        if self.debug_mode:
+            print("Response command: " + str(response))
+            MessageHelper.send_message_to_app_insights("ResponseCommand", str(response))
+
+        return response
 
     def process(self, message_byte_array):
         received_command = CommandDeserializer(message_byte_array).deserialize()
-        return handler.handle_command(received_command)
+
+        if self.debug_mode:
+            print("Received command: " + str(received_command))
+            MessageHelper.send_message_to_app_insights("ReceivedCommand", str(received_command))
+
+        response = handler.handle_command(received_command)
+
+        if self.debug_mode:
+            print("Response command: " + str(response))
+            MessageHelper.send_message_to_app_insights("ResponseCommand", str(response))
+
+        return response

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/core/protocol/CommandDeserializer.py

@@ -56,16 +56,30 @@ class CommandDeserializer:
         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)
+        
+        payload = [
+            self.read_object(self.buffer[self.position])
+            for _ in range(number_of_elements_in_payload)
+        ]
+        return Command(RuntimeName(runtime), CommandType(command_type), payload)
+
+    # old implementation
+    # 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

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/core/protocol/CommandSerializer.py

@@ -1,28 +1,29 @@
+import io
 from javonet.core.protocol.TypeSerializer import TypeSerializer
 from javonet.utils.Command import Command
 from javonet.utils.RuntimeName import RuntimeName
 from javonet.utils.connectionData.IConnectionData import IConnectionData
 
-
 class CommandSerializer:
-    buffer = []
-
     def serialize(self, root_command: Command, connection_data: IConnectionData, runtime_version=0):
-        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])
-        self.serialize_recursively(root_command)
-        return self.buffer
+        ms = io.BytesIO()
+
+        ms.write(bytes([root_command.runtime_name.value, runtime_version]))
+
+        if connection_data is not None:
+            ms.write(bytes(connection_data.serialize_connection_data()))
+        else:
+            ms.write(bytes([0, 0, 0, 0, 0, 0, 0]))
 
-    def serialize_recursively(self, command):
+        ms.write(bytes([RuntimeName.python.value, root_command.command_type.value]))
+
+        self.serialize_recursively(root_command, ms)
+        return ms.getvalue()
+
+    def serialize_recursively(self, command: Command, ms: io.BytesIO):
         for item in command.get_payload():
             if isinstance(item, Command):
-                self.insert_into_buffer(TypeSerializer.serialize_command(item))
-                self.serialize_recursively(item)
+                ms.write(bytes(TypeSerializer.serialize_command(item)))
+                self.serialize_recursively(item, ms)
             else:
-                self.insert_into_buffer(TypeSerializer.serialize_primitive(item))
-
-        return
-
-    def insert_into_buffer(self, arguments):
-        self.buffer = self.buffer + arguments
+                ms.write(bytes(TypeSerializer.serialize_primitive(item)))

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

@@ -1,7 +1,11 @@
+import sys
+import traceback
+
 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
+from javonet.utils.messageHelper.MessageHelper import MessageHelper
 
 
 class Receiver:
@@ -9,6 +13,22 @@ class Receiver:
     def __init__(self):
         self.connection_data = InMemoryConnectionData()
 
+        # Store the original excepthook
+        self.original_excepthook = sys.excepthook
+
+        # Set up global exception handler
+        def custom_excepthook(exc_type, exc_value, exc_traceback):
+            # Format the exception
+            exception_string = "".join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+            # Send to App Insights
+            MessageHelper.send_message_to_app_insights_sync("ReceiverUnhandledException", exception_string)
+            print(exception_string)
+            # Call the original handler
+            self.original_excepthook(exc_type, exc_value, exc_traceback)
+
+        # Register the custom exception handler
+        sys.excepthook = custom_excepthook
+
     def SendCommand(self, message_byte_array, messageByteArrayLen):
         return bytearray(CommandSerializer().serialize(Interpreter().process(message_byte_array), self.connection_data))
 

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

@@ -65,3 +65,26 @@ class Command:
         else:
             self.is_equal = False
         return self.is_equal
+
+    def __str__(self):
+        try:
+            result = "RuntimeName "
+            result += str(self.runtime_name).capitalize()
+            result += " "
+            result += "CommandType "
+            result += str(self.command_type)
+            result += " "
+            result += "Payload "
+
+            for i, item in enumerate(self.payload):
+                if item is None:
+                    result += "null"
+                else:
+                    result += str(item)
+
+                if i < len(self.payload) - 1:
+                    result += " "
+
+            return result
+        except Exception as ex:
+            return f"Error while converting command to string: {str(ex)}"

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

@@ -11,3 +11,6 @@ class RuntimeName(Enum):
     ruby = 6
     nodejs = 7
     cpp = 8
+
+    def __str__(self):
+        return self.name

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

@@ -0,0 +1,42 @@
+import os
+from pathlib import Path
+
+class UtilsConst:
+    _javonet_working_directory = str(Path().absolute()) + "/"
+    _config_source = ""
+    _license_key = "License key not set"
+
+    @staticmethod
+    def set_javonet_working_directory(path: str) -> None:
+        path = path.replace("\\", "/")
+        if not path.endswith("/"):
+            path = path + "/"
+
+        if not os.path.exists(path):
+            os.makedirs(path)
+            os.chmod(path, 0o700)
+
+        UtilsConst._javonet_working_directory = path
+
+    @staticmethod
+    def get_javonet_working_directory() -> str:
+        return UtilsConst._javonet_working_directory
+
+    @staticmethod
+    def set_config_source(value: str) -> None:
+        UtilsConst._config_source = value
+
+    @staticmethod
+    def get_config_source() -> str:
+        return UtilsConst._config_source
+
+    @staticmethod
+    def set_license_key(value: str) -> None:
+        if not value or value == "" or value == "your-license-key":
+            return
+
+        UtilsConst._license_key = value
+
+    @staticmethod
+    def get_license_key() -> str:
+        return UtilsConst._license_key

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

@@ -9,45 +9,49 @@ class ExceptionThrower:
 
     @staticmethod
     def throw_exception(command_exception: Command):
-        stack_classes, stack_methods, stack_lines, stack_files = "", "", "", ""
-        exception_message = "Python Exception with empty message"
-        exception_name = "Python exception"
-        javonet_stack_command = ""
-        traceback_str = ""
-
-        exception_payload_len = len(command_exception.payload)
-        if exception_payload_len >=8:
-            stack_classes, stack_methods, stack_lines, stack_files = ExceptionThrower.get_local_stack_trace(
-                command_exception.get_payload()[4],
-                command_exception.get_payload()[5],
-                command_exception.get_payload()[6],
-                command_exception.get_payload()[7])
-
-        if exception_payload_len >= 4:
-            exception_message = command_exception.get_payload()[3]
-
-        if exception_payload_len >= 3:
-            exception_name = command_exception.get_payload()[2]
-
-        if exception_payload_len >= 2:
-            javonet_stack_command = command_exception.get_payload()[1]
-
-        if exception_payload_len >= 1:
-            original_exception = ExceptionType.to_exception(command_exception.get_payload()[0])
-
-
-        for i in range(len(stack_classes)):
-            if i < len(stack_files) and stack_files[i]:
-                traceback_str += "File \"{}\"".format(stack_files[i])
-            if i < len(stack_lines) and stack_lines[i]:
-                traceback_str += ", line {}".format(stack_lines[i])
-            if i < len(stack_methods) and stack_methods[i]:
-                traceback_str += ", in {}".format(stack_methods[i])
-            traceback_str += "\n"
-            if i < len(stack_classes) and stack_classes[i]:
-                traceback_str += "    {}\n".format(stack_classes[i])
-
-        return ExceptionThrower.raise_exception(original_exception, exception_message, traceback_str)
+        try:
+            stack_classes, stack_methods, stack_lines, stack_files = "", "", "", ""
+            exception_message = "Python Exception with empty message"
+            exception_name = "Python exception"
+            javonet_stack_command = ""
+            traceback_str = ""
+            original_exception = ""
+
+            exception_payload_len = len(command_exception.payload)
+            if exception_payload_len >=8:
+                stack_classes, stack_methods, stack_lines, stack_files = ExceptionThrower.get_local_stack_trace(
+                    command_exception.get_payload()[4],
+                    command_exception.get_payload()[5],
+                    command_exception.get_payload()[6],
+                    command_exception.get_payload()[7])
+
+            if exception_payload_len >= 4:
+                exception_message = command_exception.get_payload()[3]
+
+            if exception_payload_len >= 3:
+                exception_name = command_exception.get_payload()[2]
+
+            if exception_payload_len >= 2:
+                javonet_stack_command = command_exception.get_payload()[1]
+
+            if exception_payload_len >= 1:
+                original_exception = ExceptionType.to_exception(command_exception.get_payload()[0])
+
+
+            for i in range(len(stack_classes)):
+                if i < len(stack_files) and stack_files[i]:
+                    traceback_str += "File \"{}\"".format(stack_files[i])
+                if i < len(stack_lines) and stack_lines[i]:
+                    traceback_str += ", line {}".format(stack_lines[i])
+                if i < len(stack_methods) and stack_methods[i]:
+                    traceback_str += ", in {}".format(stack_methods[i])
+                traceback_str += "\n"
+                if i < len(stack_classes) and stack_classes[i]:
+                    traceback_str += "    {}\n".format(stack_classes[i])
+
+            return ExceptionThrower.raise_exception(original_exception, exception_message, traceback_str)
+        except Exception as e:
+            return JavonetException(str(e), "Error while processing exception: " + str(command_exception), "")
 
     @staticmethod
     def raise_exception(original_exception, exception_message, traceback_str):

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

@@ -0,0 +1,86 @@
+# File: javonet/utils/messageHelper/MessageHelper.py
+import datetime
+import importlib.metadata
+import os
+import platform
+import socket
+import threading
+import urllib.request
+import urllib.error
+import json
+
+from javonet.utils.UtilsConst import UtilsConst
+
+
+def __get_host_name():
+    try:
+        return socket.gethostname()
+    except socket.error:
+        return "Unknown Host"
+
+
+def __get_package_version():
+    try:
+        return importlib.metadata.version("javonet-python-sdk")
+    except importlib.metadata.PackageNotFoundError:
+        return None
+
+
+address = "https://dc.services.visualstudio.com/v2/track"
+instrumentation_key = os.environ.get("JAVONET_INSTRUMENTATION_KEY", "2c751560-90c8-40e9-b5dd-534566514723")
+calling_runtime_name = "Python"
+javonet_version = __get_package_version()
+node_name = __get_host_name()
+os_name = platform.system()
+
+
+class MessageHelper:
+
+    @staticmethod
+    def send_message_to_app_insights(operation_name, message):
+        thread = threading.Thread(target=MessageHelper.send_message_to_app_insights_sync,
+                                  args=(operation_name, message))
+        thread.start()
+
+    @staticmethod
+    def send_message_to_app_insights_sync(operation_name, message):
+        try:
+            formatted_datetime = datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%S")
+            license_key = UtilsConst.get_license_key()
+
+            json_payload = {
+                "name": "AppEvents",
+                "time": formatted_datetime,
+                "iKey": instrumentation_key,
+                "tags": {
+                    "ai.application.ver": javonet_version,
+                    "ai.cloud.roleInstance": node_name,
+                    "ai.operation.id": "0",
+                    "ai.operation.parentId": "0",
+                    "ai.operation.name": operation_name,
+                    "ai.internal.sdkVersion": "javonet:2",
+                    "ai.internal.nodeName": node_name
+                },
+                "data": {
+                    "baseType": "EventData",
+                    "baseData": {
+                        "ver": 2,
+                        "name": message,
+                        "properties": {
+                            "OperatingSystem": os_name,
+                            "LicenseKey": license_key,
+                            "CallingTechnology": calling_runtime_name
+                        }
+                    }
+                }
+            }
+
+            data = json.dumps(json_payload).encode("utf-8")
+            req = urllib.request.Request(address, data=data, headers={'Content-Type': 'application/json'})
+            with urllib.request.urlopen(req) as response:
+                status_code = response.getcode()
+            return status_code
+        except urllib.error.HTTPError as e:
+            return e.code
+        except Exception:
+            pass