javonet-ruby-sdk 2.4.8 → 2.4.10

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/utils/connectionData/IConnectionData.py

@@ -0,0 +1,18 @@
+from abc import ABC, abstractmethod
+from javonet.utils.ConnectionType import ConnectionType
+
+
+class IConnectionData(ABC):
+    @property
+    @abstractmethod
+    def connection_type(self):
+        pass
+
+    @property
+    @abstractmethod
+    def hostname(self):
+        pass
+
+    @abstractmethod
+    def serialize_connection_data(self):
+        pass

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/utils/connectionData/InMemoryConnectionData.py

@@ -0,0 +1,23 @@
+from javonet.utils.ConnectionType import ConnectionType
+from javonet.utils.connectionData.IConnectionData import IConnectionData
+
+
+class InMemoryConnectionData(IConnectionData):
+    @property
+    def connection_type(self):
+        return ConnectionType.InMemory
+
+    @property
+    def hostname(self):
+        return ""
+
+    def serialize_connection_data(self):
+        return [self.connection_type.value, 0, 0, 0, 0, 0, 0]
+
+    def __eq__(self, other):
+        return isinstance(other, InMemoryConnectionData)
+
+    def __hash__(self):
+        hash_code = 593727026
+        hash_code = hash_code * -1521134295 + hash(self.connection_type)
+        return hash_code

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/utils/connectionData/TcpConnectionData.py

@@ -0,0 +1,67 @@
+import hashlib
+import socket
+
+from javonet.utils.ConnectionType import ConnectionType
+from javonet.utils.connectionData.IConnectionData import IConnectionData
+
+
+class TcpConnectionData(IConnectionData):
+
+    def __init__(self, hostname: str, port: int):
+        self._hostname = hostname
+        self._port = port
+        self._ip_address = ""
+        if self._hostname == "localhost":
+            self._ip_address = "127.0.0.1"
+        else:
+            try:
+                self._ip_address = socket.gethostbyname(self._hostname)
+            except socket.gaierror:
+                self._ip_address = ""
+
+    @property
+    def connection_type(self):
+        return ConnectionType.Tcp
+
+    @property
+    def hostname(self):
+        return self._hostname
+
+    @property
+    def ip_address(self):
+        return self._ip_address
+
+    @property
+    def port(self):
+        return self._port
+
+    def serialize_connection_data(self):
+        address_bytes = self.__get_address_bytes()
+        port_bytes = self.__get_pot_bytes()
+        return [self.connection_type.value] + address_bytes + port_bytes
+
+    def __get_address_bytes(self):
+        return [int(x) for x in self._ip_address.split(".")]
+
+    def __get_pot_bytes(self):
+        return [self._port & 0xFF, self._port >> 8]
+
+    def __eq__(self, other):
+        if isinstance(other, TcpConnectionData):
+            return self._ip_address == other.ip_address and self._port == other.port
+        return False
+
+    def __hash__(self):
+        return int(hashlib.sha1(f"{self._ip_address}{self._port}".encode()).hexdigest(), 16)
+
+    @hostname.setter
+    def hostname(self, value):
+        self._hostname = value
+
+    @port.setter
+    def port(self, value):
+        self._port = value
+
+    @ip_address.setter
+    def ip_address(self, value):
+        self._ip_address = value

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/utils/connectionData/WsConnectionData.py

@@ -0,0 +1,30 @@
+import hashlib
+
+from javonet.utils.ConnectionType import ConnectionType
+from javonet.utils.connectionData.IConnectionData import IConnectionData
+
+
+class WsConnectionData(IConnectionData):
+
+    def __init__(self, hostname: str):
+        self._hostname = hostname
+    @property
+    def connection_type(self):
+        return ConnectionType.WebSocket
+
+    @property
+    def hostname(self):
+        return self._hostname
+
+    def serialize_connection_data(self):
+        return [self.connection_type.value, 0, 0, 0, 0, 0, 0]
+
+    def __eq__(self, other):
+        return isinstance(other, WsConnectionData) and self._hostname == other.hostname
+
+    def __hash__(self):
+        return int(hashlib.sha1(f"{self.hostname}".encode()).hexdigest(), 16)
+
+    @hostname.setter
+    def hostname(self, value):
+        self._hostname = value

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

@@ -3,30 +3,32 @@ 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.TcpConnectionData import TcpConnectionData
-
+from javonet.utils.connectionData.IConnectionData import IConnectionData
 
 class Interpreter:
-    response = None
 
-    def execute(self, command, connection_type, tcp_connection_data: TcpConnectionData):
+    def execute(self, command, connection_data: IConnectionData):
         command_serializer = CommandSerializer()
-        serialized_command = command_serializer.serialize(command, connection_type, tcp_connection_data)
-        if (command.runtime_name == RuntimeName.python) & (connection_type == ConnectionType.InMemory):
+        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))
 
+        command_deserializer = CommandDeserializer(response, len(response))
         return command_deserializer.deserialize()
 
-    def process(self, byte_array, byte_array_len):
+    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, 0, "0.0.0.0:0")
+        encoded_response = command_serializer.serialize(response_command, connection_data)
         return encoded_response

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

@@ -1,36 +1,23 @@
-import struct
 from collections import deque
 from typing import Deque
 
 from javonet.core.protocol.TypeSerializer import TypeSerializer
 from javonet.utils.Command import Command
-from javonet.utils.ConnectionType import ConnectionType
 from javonet.utils.RuntimeName import RuntimeName
-from javonet.utils.TcpConnectionData import TcpConnectionData
+from javonet.utils.connectionData.IConnectionData import IConnectionData
 
 
 class CommandSerializer:
     byte_buffer = []
 
-    def serialize(self, root_command, connection_type, tcp_connection_data: TcpConnectionData, runtime_version=0):
+    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])
-        if connection_type == ConnectionType.Tcp:
-            self.insert_into_buffer([ConnectionType.Tcp.value])
-            self.insert_into_buffer(self.serialize_tcp(tcp_connection_data))
-        else:
-            self.insert_into_buffer([ConnectionType.InMemory.value])
-            self.insert_into_buffer([0, 0, 0, 0, 0, 0])
+        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_tcp(tcp_connection_data):
-        if tcp_connection_data is None:
-            raise Exception("tcp_connection_data is not provided")
-        return tcp_connection_data.get_address_bytes() + tcp_connection_data.get_pot_bytes()
-
     @staticmethod
     def serialize_primitive(payload_item):
         if payload_item is None:

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

@@ -1,13 +1,15 @@
 from javonet.core.interpreter.Interpreter import Interpreter
+from javonet.utils.connectionData.InMemoryConnectionData import InMemoryConnectionData
 
 
 class Receiver:
 
     def __init__(self):
         self.python_interpreter = Interpreter()
+        self.connection_data = InMemoryConnectionData()
 
     def SendCommand(self, messageByteArray, messageByteArrayLen):
-        return bytearray(self.python_interpreter.process(messageByteArray, len(messageByteArray)))
+        return bytearray(self.python_interpreter.process(messageByteArray, len(messageByteArray), self.connection_data))
 
     def HeartBeat(self, messageByteArray, messageByteArrayLen):
         response_byte_array = bytearray(2)

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/referenceCache/ReferencesCache.py

@@ -2,6 +2,7 @@ import uuid
 import threading
 from javonet.utils.CommandType import CommandType
 
+
 class ReferencesCache(object):
     _instance = None
     references_cache = dict()
@@ -35,4 +36,4 @@ class ReferencesCache(object):
                 del self.references_cache[reference_guid]
                 return 0
             except KeyError:
-                raise Exception("Object not found in references")
+                raise Exception("Object not found in references")

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/transmitter/Transmitter.py

@@ -8,20 +8,8 @@ class Transmitter:
         return TransmitterWrapper.send_command(message)
 
     @staticmethod
-    def __activate(license_key="", proxy_host="", proxy_user_name="", proxy_user_password=""):
-        return TransmitterWrapper.activate(license_key, proxy_host, proxy_user_name, proxy_user_password)
-
-    @staticmethod
-    def activate_with_license_file():
-        return Transmitter.__activate()
-
-    @staticmethod
-    def activate_with_credentials(license_key):
-        return Transmitter.__activate(license_key)
-
-    @staticmethod
-    def activate_with_credentials_and_proxy(license_key, proxy_host, proxy_user_name, proxy_user_password):
-        return Transmitter.__activate(license_key, proxy_host, proxy_user_name, proxy_user_password)
+    def activate(license_key):
+        return TransmitterWrapper.activate(license_key)
 
     @staticmethod
     def set_config_source(source_path):

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

@@ -47,15 +47,15 @@ class TransmitterWrapper:
                 "Javonet native error code: " + str(response_array_len) + ". " + str(error_message))
 
     @staticmethod
-    def activate(license_key, proxy_host, proxy_user_name, proxy_user_password):
+    def activate(license_key):
         activate = TransmitterWrapper.python_lib.Activate
         activate.restype = c_int
         activate.argtypes = [c_char_p, c_char_p, c_char_p, c_char_p]
 
         activation_result = activate(license_key.encode('ascii'),
-                                     proxy_host.encode('ascii'),
-                                     proxy_user_name.encode('ascii'),
-                                     proxy_user_password.encode('ascii'))
+                                     "".encode('ascii'),
+                                     "".encode('ascii'),
+                                     "".encode('ascii'))
 
         if activation_result < 0:
             get_native_error = TransmitterWrapper.python_lib.GetNativeError

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/webSocketClient/WebSocketClient.py

@@ -0,0 +1,32 @@
+import asyncio
+import struct
+from websockets.sync.client import connect
+
+from javonet.utils.connectionData.WsConnectionData import WsConnectionData
+
+
+class WebSocketClient:
+    _instance = None
+    clients = dict()
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(WebSocketClient, cls).__new__(cls)
+        return cls._instance
+
+    def add_or_get_client(self, connection_data: WsConnectionData):
+        if connection_data.hostname in self.clients:
+            return self.clients[connection_data.hostname]
+        else:
+            self.clients[connection_data.hostname] = connect(connection_data.hostname)
+            return self.clients[connection_data.hostname]
+
+    def send_message(self, connection_data: WsConnectionData, serialized_command):
+        byte_array = struct.pack("B" * len(serialized_command), *serialized_command)
+        return self.send(connection_data, byte_array)
+
+    def send(self, connection_data: WsConnectionData, byte_array):
+        websocket = self.add_or_get_client(connection_data)
+        websocket.send(byte_array)
+        response = websocket.recv()
+        return response

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/utils/ConnectionType.py

@@ -4,3 +4,4 @@ from enum import Enum
 class ConnectionType(Enum):
     InMemory = 0
     Tcp = 1
+    WebSocket = 2

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/utils/connectionData/IConnectionData.py

@@ -0,0 +1,18 @@
+from abc import ABC, abstractmethod
+from javonet.utils.ConnectionType import ConnectionType
+
+
+class IConnectionData(ABC):
+    @property
+    @abstractmethod
+    def connection_type(self):
+        pass
+
+    @property
+    @abstractmethod
+    def hostname(self):
+        pass
+
+    @abstractmethod
+    def serialize_connection_data(self):
+        pass

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/utils/connectionData/InMemoryConnectionData.py

@@ -0,0 +1,23 @@
+from javonet.utils.ConnectionType import ConnectionType
+from javonet.utils.connectionData.IConnectionData import IConnectionData
+
+
+class InMemoryConnectionData(IConnectionData):
+    @property
+    def connection_type(self):
+        return ConnectionType.InMemory
+
+    @property
+    def hostname(self):
+        return ""
+
+    def serialize_connection_data(self):
+        return [self.connection_type.value, 0, 0, 0, 0, 0, 0]
+
+    def __eq__(self, other):
+        return isinstance(other, InMemoryConnectionData)
+
+    def __hash__(self):
+        hash_code = 593727026
+        hash_code = hash_code * -1521134295 + hash(self.connection_type)
+        return hash_code

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/utils/connectionData/TcpConnectionData.py

@@ -0,0 +1,67 @@
+import hashlib
+import socket
+
+from javonet.utils.ConnectionType import ConnectionType
+from javonet.utils.connectionData.IConnectionData import IConnectionData
+
+
+class TcpConnectionData(IConnectionData):
+
+    def __init__(self, hostname: str, port: int):
+        self._hostname = hostname
+        self._port = port
+        self._ip_address = ""
+        if self._hostname == "localhost":
+            self._ip_address = "127.0.0.1"
+        else:
+            try:
+                self._ip_address = socket.gethostbyname(self._hostname)
+            except socket.gaierror:
+                self._ip_address = ""
+
+    @property
+    def connection_type(self):
+        return ConnectionType.Tcp
+
+    @property
+    def hostname(self):
+        return self._hostname
+
+    @property
+    def ip_address(self):
+        return self._ip_address
+
+    @property
+    def port(self):
+        return self._port
+
+    def serialize_connection_data(self):
+        address_bytes = self.__get_address_bytes()
+        port_bytes = self.__get_pot_bytes()
+        return [self.connection_type.value] + address_bytes + port_bytes
+
+    def __get_address_bytes(self):
+        return [int(x) for x in self._ip_address.split(".")]
+
+    def __get_pot_bytes(self):
+        return [self._port & 0xFF, self._port >> 8]
+
+    def __eq__(self, other):
+        if isinstance(other, TcpConnectionData):
+            return self._ip_address == other.ip_address and self._port == other.port
+        return False
+
+    def __hash__(self):
+        return int(hashlib.sha1(f"{self._ip_address}{self._port}".encode()).hexdigest(), 16)
+
+    @hostname.setter
+    def hostname(self, value):
+        self._hostname = value
+
+    @port.setter
+    def port(self, value):
+        self._port = value
+
+    @ip_address.setter
+    def ip_address(self, value):
+        self._ip_address = value

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/utils/connectionData/WsConnectionData.py

@@ -0,0 +1,30 @@
+import hashlib
+
+from javonet.utils.ConnectionType import ConnectionType
+from javonet.utils.connectionData.IConnectionData import IConnectionData
+
+
+class WsConnectionData(IConnectionData):
+
+    def __init__(self, hostname: str):
+        self._hostname = hostname
+    @property
+    def connection_type(self):
+        return ConnectionType.WebSocket
+
+    @property
+    def hostname(self):
+        return self._hostname
+
+    def serialize_connection_data(self):
+        return [self.connection_type.value, 0, 0, 0, 0, 0, 0]
+
+    def __eq__(self, other):
+        return isinstance(other, WsConnectionData) and self._hostname == other.hostname
+
+    def __hash__(self):
+        return int(hashlib.sha1(f"{self.hostname}".encode()).hexdigest(), 16)
+
+    @hostname.setter
+    def hostname(self, value):
+        self._hostname = value

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

@@ -3,30 +3,32 @@ 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.TcpConnectionData import TcpConnectionData
-
+from javonet.utils.connectionData.IConnectionData import IConnectionData
 
 class Interpreter:
-    response = None
 
-    def execute(self, command, connection_type, tcp_connection_data: TcpConnectionData):
+    def execute(self, command, connection_data: IConnectionData):
         command_serializer = CommandSerializer()
-        serialized_command = command_serializer.serialize(command, connection_type, tcp_connection_data)
-        if (command.runtime_name == RuntimeName.python) & (connection_type == ConnectionType.InMemory):
+        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))
 
+        command_deserializer = CommandDeserializer(response, len(response))
         return command_deserializer.deserialize()
 
-    def process(self, byte_array, byte_array_len):
+    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, 0, "0.0.0.0:0")
+        encoded_response = command_serializer.serialize(response_command, connection_data)
         return encoded_response