javonet-ruby-sdk 2.6.10 → 2.6.11

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

@@ -11,190 +11,209 @@ from javonet.utils.StringEncodingMode import StringEncodingMode
 from javonet.utils.Type import Type
 
 
+class _DeserializerState(object):
+    """Internal state holder for deserialization."""
+    def __init__(self, buffer):
+        self.buffer = buffer
+        self.buffer_len = len(buffer)
+        self.position = 0
+
+
 class CommandDeserializer(object):
     """
     Class responsible for command deserialization.
     """
-    position = 0
-    buffer = []
-    command = 0
-    buffer_len = 0
 
-    def __init__(self, buffer):
+    @staticmethod
+    def deserialize(buffer):
         """
-        Initializes a new command deserializer.
+        Deserializes a command from a buffer.
 
         :param buffer: Buffer with data to deserialize
+        :return: Deserialized command
         """
-        self.buffer = buffer
-        self.buffer_len = len(buffer)
-        if self.buffer_len < 11:
+        if len(buffer) < 11:
             raise ValueError("Buffer too small to contain a command header.")
-        self.command = Command(RuntimeName(buffer[0]), CommandType(buffer[10]), [])
-        self.position = 11
-
-    def is_at_end(self):
+        
+        state = _DeserializerState(buffer)
+        command = Command(RuntimeName(buffer[0]), CommandType(buffer[10]), [])
+        state.position = 11
+        
+        while not CommandDeserializer._is_at_end(state):
+            command = command.add_arg_to_payload(CommandDeserializer._read_object(state))
+        
+        return command
+
+    @staticmethod
+    def _is_at_end(state):
         """
         Checks if the end of buffer has been reached.
 
+        :param state: Deserializer state
         :return: True if end of buffer is reached, False otherwise
         """
-        return self.position >= self.buffer_len
+        return state.position >= state.buffer_len
 
-    def deserialize(self):
-        """
-        Deserializes a command.
-
-        :return: Deserialized command
-        """
-        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 _check_buffer(self, required_size):
+    @staticmethod
+    def _check_buffer(state, required_size):
         """Checks if there are enough bytes left in the buffer."""
-        if self.position + required_size > self.buffer_len:
+        if state.position + required_size > state.buffer_len:
             raise IndexError("Not enough data in buffer to read next value.")
 
-    def read_object(self, type_num):
+    @staticmethod
+    def _read_object(state):
         """
         Reads an object from the buffer based on its type.
 
-        :param type_num: Type number
+        :param state: Deserializer state
         :return: Read object
         """
+        type_num = state.buffer[state.position]
         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
+            Type.Command: CommandDeserializer._read_command,
+            Type.JavonetString: CommandDeserializer._read_string,
+            Type.JavonetInteger: CommandDeserializer._read_int,
+            Type.JavonetBoolean: CommandDeserializer._read_bool,
+            Type.JavonetFloat: CommandDeserializer._read_float,
+            Type.JavonetByte: CommandDeserializer._read_byte,
+            Type.JavonetChar: CommandDeserializer._read_char,
+            Type.JavonetLongLong: CommandDeserializer._read_longlong,
+            Type.JavonetDouble: CommandDeserializer._read_double,
+            Type.JavonetUnsignedLongLong: CommandDeserializer._read_ullong,
+            Type.JavonetUnsignedInteger: CommandDeserializer._read_uint,
+            Type.JavonetNoneType: CommandDeserializer._read_none
         }
         func = switch.get(type_value)
         if func is None:
             raise ValueError("Type not supported: " + str(type_num))
-        return func()
+        return func(state)
 
-    def read_command(self):
+    @staticmethod
+    def _read_command(state):
         """
         Reads a command from the buffer.
 
+        :param state: Deserializer state
         :return: Read command
         """
-        self._check_buffer(7)
-        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
+        CommandDeserializer._check_buffer(state, 7)
+        p = state.position
+        number_of_elements_in_payload = TypeDeserializer.deserialize_int(state.buffer[p + 1: p + 5])
+        runtime = state.buffer[p + 5]
+        command_type = state.buffer[p + 6]
+        state.position += 7
 
         payload = []
         for _ in xrange(number_of_elements_in_payload):
-            payload.append(self.read_object(self.buffer[self.position]))
+            payload.append(CommandDeserializer._read_object(state))
 
         return Command(RuntimeName(runtime), CommandType(command_type), payload)
 
-    def read_string(self):
+    @staticmethod
+    def _read_string(state):
         """
         Reads a string from the buffer.
 
+        :param state: Deserializer state
         :return: Read string
         """
-        self._check_buffer(6)
-        p = self.position
-        string_encoding_mode = StringEncodingMode(self.buffer[p + 1])
-        size = TypeDeserializer.deserialize_int(self.buffer[p + 2:p + 6])
-        self.position += 6
-        self._check_buffer(size)
-        p = self.position
-        self.position += size
-        return TypeDeserializer.deserialize_string(string_encoding_mode, self.buffer[p:p + size])
-
-    def read_int(self):
+        CommandDeserializer._check_buffer(state, 6)
+        p = state.position
+        string_encoding_mode = StringEncodingMode(state.buffer[p + 1])
+        size = TypeDeserializer.deserialize_int(state.buffer[p + 2:p + 6])
+        state.position += 6
+        CommandDeserializer._check_buffer(state, size)
+        p = state.position
+        state.position += size
+        return TypeDeserializer.deserialize_string(string_encoding_mode, state.buffer[p:p + size])
+
+    @staticmethod
+    def _read_int(state):
         size = 4
-        self._check_buffer(size + 2)
-        self.position += 2
-        p = self.position
-        self.position += size
-        return TypeDeserializer.deserialize_int(self.buffer[p:p + size])
-
-    def read_bool(self):
+        CommandDeserializer._check_buffer(state, size + 2)
+        state.position += 2
+        p = state.position
+        state.position += size
+        return TypeDeserializer.deserialize_int(state.buffer[p:p + size])
+
+    @staticmethod
+    def _read_bool(state):
         size = 1
-        self._check_buffer(size + 2)
-        self.position += 2
-        p = self.position
-        self.position += size
-        return TypeDeserializer.deserialize_bool(self.buffer[p:p + size])
-
-    def read_float(self):
+        CommandDeserializer._check_buffer(state, size + 2)
+        state.position += 2
+        p = state.position
+        state.position += size
+        return TypeDeserializer.deserialize_bool(state.buffer[p:p + size])
+
+    @staticmethod
+    def _read_float(state):
         size = 4
-        self._check_buffer(size + 2)
-        self.position += 2
-        p = self.position
-        self.position += size
-        return TypeDeserializer.deserialize_float(self.buffer[p:p + size])
-
-    def read_byte(self):
+        CommandDeserializer._check_buffer(state, size + 2)
+        state.position += 2
+        p = state.position
+        state.position += size
+        return TypeDeserializer.deserialize_float(state.buffer[p:p + size])
+
+    @staticmethod
+    def _read_byte(state):
         size = 1
-        self._check_buffer(size + 2)
-        self.position += 2
-        p = self.position
-        self.position += size
-        return TypeDeserializer.deserialize_byte(self.buffer[p:p + size])
-
-    def read_char(self):
+        CommandDeserializer._check_buffer(state, size + 2)
+        state.position += 2
+        p = state.position
+        state.position += size
+        return TypeDeserializer.deserialize_byte(state.buffer[p:p + size])
+
+    @staticmethod
+    def _read_char(state):
         size = 1
-        self._check_buffer(size + 2)
-        self.position += 2
-        p = self.position
-        self.position += size
-        return TypeDeserializer.deserialize_char(self.buffer[p:p + size])
-
-    def read_longlong(self):
+        CommandDeserializer._check_buffer(state, size + 2)
+        state.position += 2
+        p = state.position
+        state.position += size
+        return TypeDeserializer.deserialize_char(state.buffer[p:p + size])
+
+    @staticmethod
+    def _read_longlong(state):
         size = 8
-        self._check_buffer(size + 2)
-        self.position += 2
-        p = self.position
-        self.position += size
-        return TypeDeserializer.deserialize_longlong(self.buffer[p:p + size])
-
-    def read_double(self):
+        CommandDeserializer._check_buffer(state, size + 2)
+        state.position += 2
+        p = state.position
+        state.position += size
+        return TypeDeserializer.deserialize_longlong(state.buffer[p:p + size])
+
+    @staticmethod
+    def _read_double(state):
         size = 8
-        self._check_buffer(size + 2)
-        self.position += 2
-        p = self.position
-        self.position += size
-
-        return TypeDeserializer.deserialize_double(self.buffer[p:p + size])
-
-    def read_ullong(self):
+        CommandDeserializer._check_buffer(state, size + 2)
+        state.position += 2
+        p = state.position
+        state.position += size
+        return TypeDeserializer.deserialize_double(state.buffer[p:p + size])
+
+    @staticmethod
+    def _read_ullong(state):
         size = 8
-        self._check_buffer(size + 2)
-        self.position += 2
-        p = self.position
-        self.position += size
-        return TypeDeserializer.deserialize_ullong(self.buffer[p:p + size])
-
-    def read_uint(self):
+        CommandDeserializer._check_buffer(state, size + 2)
+        state.position += 2
+        p = state.position
+        state.position += size
+        return TypeDeserializer.deserialize_ullong(state.buffer[p:p + size])
+
+    @staticmethod
+    def _read_uint(state):
         size = 4
-        self._check_buffer(size + 2)
-        self.position += 2
-        p = self.position
-        self.position += size
-        return TypeDeserializer.deserialize_uint(self.buffer[p:p + size])
-
-    def read_none(self):
+        CommandDeserializer._check_buffer(state, size + 2)
+        state.position += 2
+        p = state.position
+        state.position += size
+        return TypeDeserializer.deserialize_uint(state.buffer[p:p + size])
+
+    @staticmethod
+    def _read_none(state):
         size = 1
-        self._check_buffer(size + 2)
-        self.position += 2
-        p = self.position
-        self.position += size
-        return TypeDeserializer.deserialize_none(self.buffer[p:p + size])
+        CommandDeserializer._check_buffer(state, size + 2)
+        state.position += 2
+        p = state.position
+        state.position += size
+        return TypeDeserializer.deserialize_none(state.buffer[p:p + size])

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

@@ -15,9 +15,9 @@ class CommandSerializer(object):
     """
     Class responsible for command serialization.
     """
-    buffer = []
 
-    def serialize(self, root_command, connection_data, runtime_version=0):
+    @staticmethod
+    def serialize(root_command, connection_data, runtime_version=0):
         """
         Serializes a command.
 
@@ -26,36 +26,40 @@ class CommandSerializer(object):
         :param runtime_version: Runtime version
         :return: Serialized command
         """
-        self.buffer = []  # Reset buffer for each serialization
-        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.python27.value, root_command.command_type.value])
-        self.serialize_recursively(root_command)
-        return self.buffer
-
-    def serialize_recursively(self, command):
+        buffer = []  # Reset buffer for each serialization
+        CommandSerializer._insert_into_buffer(buffer, [root_command.runtime_name.value, runtime_version])
+        CommandSerializer._insert_into_buffer(buffer, connection_data.serialize_connection_data())
+        CommandSerializer._insert_into_buffer(buffer, [RuntimeName.python27.value, root_command.command_type.value])
+        CommandSerializer._serialize_recursively(buffer, root_command)
+        return buffer
+
+    @staticmethod
+    def _serialize_recursively(buffer, command):
         """
         Serializes a command recursively.
 
+        :param buffer: Buffer to serialize into
         :param command: Command to serialize
         """
-        for item in command.get_payload():
+        for item in command.payload:
             if isinstance(item, Command):
-                self.insert_into_buffer(TypeSerializer.serialize_command(item))
-                self.serialize_recursively(item)
+                CommandSerializer._insert_into_buffer(buffer, TypeSerializer.serialize_command(item))
+                CommandSerializer._serialize_recursively(buffer, item)
             elif TypesHandler.is_primitive_or_none(item):
-                self.insert_into_buffer(TypeSerializer.serialize_primitive(item))
+                CommandSerializer._insert_into_buffer(buffer, TypeSerializer.serialize_primitive(item))
             else:
                 cached_reference = ReferencesCache().cache_reference(item)
                 ref_command = Command(RuntimeName.python, CommandType.Reference, cached_reference)
-                self.serialize_recursively(ref_command)
+                CommandSerializer._serialize_recursively(buffer, ref_command)
 
         return
 
-    def insert_into_buffer(self, arguments):
+    @staticmethod
+    def _insert_into_buffer(buffer, arguments):
         """
         Inserts arguments into the buffer.
 
+        :param buffer: Buffer to insert into
         :type arguments: list
         """
-        self.buffer = self.buffer + arguments 
+        buffer.extend(arguments) 

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

@@ -6,7 +6,6 @@ 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.core.protocol.CommandDeserializer import CommandDeserializer
 from javonet.utils.Command import Command
 from javonet.utils.CommandType import CommandType
 from javonet.utils.RuntimeName import RuntimeName
@@ -18,29 +17,31 @@ class Receiver(object):
     Class implementing the message receiver.
     """
 
-    def __init__(self):
-        self.connection_data = InMemoryConnectionData()
-
-    def SendCommand(self, message_byte_array_as_string, messageByteArrayLen):
+    @staticmethod
+    def SendCommand(message_byte_array_as_string):
         try:
+            connection_data = InMemoryConnectionData()
             message_byte_array = bytearray(message_byte_array_as_string)
-            response_command = Interpreter().process(message_byte_array)
-            serialized_response = CommandSerializer().serialize(response_command, self.connection_data)
+            response_command = Interpreter.process(message_byte_array)
+            serialized_response = CommandSerializer.serialize(response_command, connection_data)
             return bytearray(serialized_response)
         except Exception as ex:
+            connection_data = InMemoryConnectionData()
             exception_command = ExceptionSerializer.serialize_exception(
                 ex,
                 Command(RuntimeName.python27, CommandType.Exception, [])
             )
-            serialized_exception = CommandSerializer().serialize(exception_command, self.connection_data)
+            serialized_exception = CommandSerializer.serialize(exception_command, connection_data)
             return bytearray(serialized_exception)
 
-    def HeartBeat(self, message_byte_array_as_string, messageByteArrayLen):
+    @staticmethod
+    def HeartBeat(message_byte_array_as_string):
         message_byte_array = bytearray(message_byte_array_as_string)
         response_byte_array = bytearray(2)
         response_byte_array[0] = message_byte_array[11]
         response_byte_array[1] = message_byte_array[12] - 2
         return response_byte_array
 
-    def GetRuntimeInfo(self):
+    @staticmethod
+    def GetRuntimeInfo():
         return RuntimeLogger().get_runtime_info()

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

@@ -5,7 +5,6 @@ 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):
@@ -14,11 +13,26 @@ class Command(object):
 
         :param runtime_name: Runtime environment name
         :param command_type: Command type
-        :param payload: Command payload
+        :param payload: Command payload (list, tuple, single value, or None)
+                        If not provided, creates empty list.
+                        If None is explicitly passed, creates [None].
         """
         self.runtime_name = runtime_name
         self.command_type = command_type
-        self.payload = payload
+        
+        if isinstance(payload, list) and len(payload) == 0:
+            # Payload is empty - create empty list
+            self.payload = []
+        elif payload is None:
+            # None explicitly passed - wrap in list
+            self.payload = [None]
+        elif isinstance(payload, (list, tuple)):
+            # Convert to list if tuple, reuse list directly
+            # None values in the payload are preserved
+            self.payload = list(payload) if isinstance(payload, tuple) else payload
+        else:
+            # Single item - wrap in list
+            self.payload = [payload]
 
     def get_payload(self):
         """
@@ -37,7 +51,7 @@ class Command(object):
         :param runtime_name: Runtime environment name
         :return: New response command
         """
-        return Command(runtime_name, CommandType.Value, [response])
+        return Command(runtime_name, CommandType.Value, response)
 
     @staticmethod
     def create_reference(guid, runtime_name):
@@ -48,7 +62,7 @@ class Command(object):
         :param runtime_name: Runtime environment name
         :return: New reference command
         """
-        return Command(runtime_name, CommandType.Reference, [guid])
+        return Command(runtime_name, CommandType.Reference, guid)
 
     @staticmethod
     def create_array_response(array, runtime_name):
@@ -61,39 +75,64 @@ class Command(object):
         """
         return Command(runtime_name, CommandType.Array, array)
 
-    def drop_first_payload_argument(self):
+    def drop_first_payload_arg(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)
+        if len(self.payload) <= 1:
+            return Command(self.runtime_name, self.command_type, [])
+        
+        new_length = len(self.payload) - 1
+        new_payload = [None] * new_length
+        
+        # Copy from index 1 to end
+        for i in xrange(new_length):
+            new_payload[i] = self.payload[i + 1]
+        
+        return Command(self.runtime_name, self.command_type, new_payload)
 
-    def add_arg_to_payload(self, argument):
+    def add_arg_to_payload(self, arg):
         """
         Adds an argument to the payload.
 
-        :param argument: Argument to add
+        :param arg: 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)
+        old_length = len(self.payload)
+        new_payload = [None] * (old_length + 1)
+        
+        # Copy existing payload
+        for i in xrange(old_length):
+            new_payload[i] = self.payload[i]
+        
+        # Add new argument at the end
+        new_payload[old_length] = arg
+        
+        return Command(self.runtime_name, self.command_type, new_payload)
 
-    def prepend_arg_to_payload(self, current_command):
+    def prepend_arg_to_payload(self, arg_command):
         """
         Adds an argument to the beginning of the payload.
 
-        :param current_command: Current command
+        :param arg_command: Command to prepend
         :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)
+        if arg_command is None:
+            return self
+        
+        old_length = len(self.payload)
+        new_payload = [None] * (old_length + 1)
+        
+        # Put new element at the front
+        new_payload[0] = arg_command
+        
+        # Copy existing payload starting from index 1
+        for i in xrange(old_length):
+            new_payload[i + 1] = self.payload[i]
+        
+        return Command(self.runtime_name, self.command_type, new_payload)
 
     def to_string(self):
         """
@@ -101,8 +140,29 @@ class Command(object):
 
         :return: Text representation of the command
         """
-        return 'Target runtime: ' + str(self.runtime_name) + ' Command type: ' + str(
-            self.command_type) + ' Payload: ' + str(self.payload)
+        try:
+            sb = []
+            sb.append("RuntimeName ")
+            sb.append(str(self.runtime_name))
+            sb.append(" ")
+            sb.append("CommandType ")
+            sb.append(str(self.command_type))
+            sb.append(" ")
+            sb.append("Payload ")
+            
+            payload = self.payload
+            payload_len = len(payload)
+            
+            for i in xrange(payload_len):
+                item = payload[i]
+                sb.append(str(item) if item is not None else "null")
+                
+                if i < payload_len - 1:
+                    sb.append(" ")
+            
+            return ''.join(sb)
+        except Exception as ex:
+            return "Error while converting command to string:" + str(ex)
 
     def __eq__(self, other):
         """
@@ -137,8 +197,13 @@ class Command(object):
         
         # Compare each payload item
         for i in range(len(self.payload)):
+            # Handle None values explicitly
+            if self.payload[i] is None and other.payload[i] is None:
+                continue
+            elif self.payload[i] is None or other.payload[i] is None:
+                return False
             # For simple types
-            if self.payload[i] != other.payload[i]:
+            elif self.payload[i] != other.payload[i]:
                 return False
                 
         return True

data/lib/javonet-ruby-sdk/Binaries/version.txt

@@ -1 +1 @@
-2.6.10
+2.6.11