javonet-ruby-sdk 2.6.11 → 2.6.12

data/lib/javonet-ruby-sdk/Binaries/Perl/Linux/X64/lib/Javonet/Core/Exception/SdkExceptionHelper.pm

@@ -40,7 +40,7 @@ sub send_exception_to_app_insights {
         }
         catch ( $e ) {
             $javonet_version = "2.0.0";
-        }
+        };
 
         my $node_name = eval {hostname()} || "Unknown Host";
 
@@ -86,8 +86,8 @@ sub send_exception_to_app_insights {
         return $response_code;
     }
     catch ( $e ) {
-        return Exception->new($e);
+        return 500;
     }
 }
 
-1;
+1;

data/lib/javonet-ruby-sdk/Binaries/Perl/Linux/X64/lib/Javonet/Core/Protocol/CommandDeserializer.pm

@@ -9,202 +9,258 @@ use aliased 'Javonet::Core::Protocol::TypeDeserializer' => 'TypeDeserializer';
 use Exporter qw(import);
 our @EXPORT = qw(deserialize);
 
-# Static deserialize method - takes byte array and returns Command
+# Static deserialize method
 sub deserialize {
     my ($class, $byte_array_ref) = @_;
     my @buffer = ref $byte_array_ref eq 'ARRAY' ? @$byte_array_ref : @$byte_array_ref;
     my $position = 11;  # Start position after header
+    
     my $command = PerlCommand->new(
         runtime => $buffer[0],
         command_type => $buffer[10],
         payload => []
     );
     
-    # Helper function to check if at end
-    my $isAtEnd = sub {
-        my $length = @buffer;
-        return $position == $length;
-    };
-    
-    # Define read functions first (they will be referenced by readObject and readCommand)
-    my $readString = sub {
-        my $p = $position;
-        my $string_encoding_mode = $buffer[$p + 1];
-        my @int_buffer = @buffer[$p + 2 .. $p + 5];
-        my $size = TypeDeserializer->deserializeInt(\@int_buffer);
-        $position += 6;
-        $p = $position;
-        $position += $size;
-        my @string_buffer = @buffer[$p .. $p + $size - 1];
-        my $decodedString = TypeDeserializer->deserializeString($string_encoding_mode, \@string_buffer);
-        return $decodedString;
-    };
-    
-    my $readInt = sub {
-        $position += 2;
-        my $p = $position;
-        $position += 4;
-        my @int_buffer = @buffer[$p .. $p + 3];
-        return TypeDeserializer->deserializeInt(\@int_buffer);
-    };
-    
-    my $readBool = sub {
-        $position += 2;
-        my $p = $position;
-        $position += 1;
-        my $bool_buffer = $buffer[$p];
-        return TypeDeserializer->deserializeBool($bool_buffer);
-    };
-    
-    my $readFloat = sub {
-        $position += 2;
-        my $p = $position;
-        $position += 4;
-        my @float_buffer = @buffer[$p .. $p + 3];
-        return TypeDeserializer->deserializeFloat(\@float_buffer);
-    };
-    
-    my $readByte = sub {
-        $position += 2;
-        my $p = $position;
-        $position += 1;
-        my $byte_buffer = $buffer[$p];
-        return TypeDeserializer->deserializeByte($byte_buffer);
-    };
-    
-    my $readChar = sub {
-        $position += 2;
-        my $p = $position;
-        $position += 1;
-        my $char_buffer = $buffer[$p];
-        return TypeDeserializer->deserializeChar($char_buffer);
-    };
-    
-    my $readLongLong = sub {
-        $position += 2;
-        my $p = $position;
-        $position += 8;
-        my @longlong_buffer = @buffer[$p .. $p + 7];
-        return TypeDeserializer->deserializeLongLong(\@longlong_buffer);
-    };
-    
-    my $readDouble = sub {
-        $position += 2;
-        my $p = $position;
-        $position += 8;
-        my @double_buffer = @buffer[$p .. $p + 7];
-        return TypeDeserializer->deserializeDouble(\@double_buffer);
-    };
-    
-    my $readUnsignedLongLong = sub {
-        $position += 2;
-        my $p = $position;
-        $position += 8;
-        my @ulonglong_buffer = @buffer[$p .. $p + 7];
-        return TypeDeserializer->deserializeULongLong(\@ulonglong_buffer);
-    };
-    
-    my $readUnsignedInt = sub {
-        $position += 2;
-        my $p = $position;
-        $position += 4;
-        my @uint_buffer = @buffer[$p .. $p + 3];
-        return TypeDeserializer->deserializeUInt(\@uint_buffer);
-    };
-    
-    my $readUndef = sub {
-        $position += 2;
-        my $p = $position;
-        $position += 1;
-        my $undef_buffer = $buffer[$p];
-        return TypeDeserializer->deserializeUndef($undef_buffer);
-    };
-    
-    # Declare readObject first for mutual recursion
-    my $readObject;
-    
-    # Helper function to read command recursively (needs readObject)
-    my $readCommandRecursively;
-    $readCommandRecursively = sub {
-        my ($numberOfArgumentInPayloadLeft, $cmd) = @_;
-        
-        if ($numberOfArgumentInPayloadLeft == 0) {
-            return $cmd;
-        }
-        else {
-            my $p = $position;
-            my @int_buffer = @buffer[$p + 1 .. $p + 4];
-            my $argSize = TypeDeserializer->deserializeInt(\@int_buffer);
-            $cmd = $cmd->AddArgToPayload($readObject->($buffer[$p]));
-            return $readCommandRecursively->($numberOfArgumentInPayloadLeft - 1, $cmd);
-        }
-    };
-    
-    # Helper function to read command (needs readCommandRecursively and readObject)
-    my $readCommand = sub {
-        my $p = $position;
-        my @int_buffer = @buffer[$p + 1 .. $p + 4];
-        my $numberOfArgumentInPayload = TypeDeserializer->deserializeInt(\@int_buffer);
-        my $runtime = $buffer[$p + 5];
-        my $commandType = $buffer[$p + 6];
-        
-        $position += 7;
-        my $returnCommand = PerlCommand->new(runtime => $runtime, command_type => $commandType);
-        return $readCommandRecursively->($numberOfArgumentInPayload, $returnCommand);
-    };
-    
-    # Helper function to read object (references all read functions)
-    $readObject = sub {
-        my ($type_num) = @_;
-        if ($type_num == Type->get_type('Command')) {
-            return $readCommand->();
-        }
-        elsif ($type_num == Type->get_type('JavonetString')) {
-            return $readString->();
-        }
-        elsif ($type_num == Type->get_type('JavonetInteger')) {
-            return $readInt->();
-        }
-        elsif ($type_num == Type->get_type('JavonetBool')) {
-            return $readBool->();
-        }
-        elsif ($type_num == Type->get_type('JavonetFloat')) {
-            return $readFloat->();
-        }
-        elsif ($type_num == Type->get_type('JavonetByte')) {
-            return $readByte->();
-        }
-        elsif ($type_num == Type->get_type('JavonetChar')) {
-            return $readChar->();
-        }
-        elsif ($type_num == Type->get_type('JavonetLongLong')) {
-            return $readLongLong->();
-        }
-        elsif ($type_num == Type->get_type('JavonetDouble')) {
-            return $readDouble->();
-        }
-        elsif ($type_num == Type->get_type('JavonetUnsignedLongLong')) {
-            return $readUnsignedLongLong->();
-        }
-        elsif ($type_num == Type->get_type('JavonetUnsignedInteger')) {
-            return $readUnsignedInt->();
-        }
-        elsif ($type_num == Type->get_type('JavonetNull')) {
-            return $readUndef->();
-        }
-        else {
-            die "Type is not supported: $type_num";
-        }
-    };
-    
-    
-    # Decode the command
-    while (!$isAtEnd->()) {
-        $command = $command->AddArgToPayload($readObject->($buffer[$position]));
-        # Note: position is managed inside readObject and helper functions
+    # Use position reference to simulate ref parameter
+    my $position_ref = \$position;
+    
+    while ($position < @buffer) {
+        $command = $command->AddArgToPayload(ReadObject(\@buffer, $position_ref));
     }
     
     return $command;
 }
 
+# ReadObject
+sub ReadObject {
+    my ($buffer_ref, $position_ref) = @_;
+    my @buffer = @$buffer_ref;
+    my $position = $$position_ref;
+    
+    my $type = $buffer[$position];
+    
+    if ($type == Type->get_type('Command')) {
+        return ReadCommand($buffer_ref, $position_ref);
+    }
+    elsif ($type == Type->get_type('JavonetString')) {
+        return ReadString($buffer_ref, $position_ref);
+    }
+    elsif ($type == Type->get_type('JavonetInteger')) {
+        return ReadInt($buffer_ref, $position_ref);
+    }
+    elsif ($type == Type->get_type('JavonetBool')) {
+        return ReadBool($buffer_ref, $position_ref);
+    }
+    elsif ($type == Type->get_type('JavonetFloat')) {
+        return ReadFloat($buffer_ref, $position_ref);
+    }
+    elsif ($type == Type->get_type('JavonetByte')) {
+        return ReadByte($buffer_ref, $position_ref);
+    }
+    elsif ($type == Type->get_type('JavonetChar')) {
+        return ReadChar($buffer_ref, $position_ref);
+    }
+    elsif ($type == Type->get_type('JavonetLongLong')) {
+        return ReadLong($buffer_ref, $position_ref);
+    }
+    elsif ($type == Type->get_type('JavonetDouble')) {
+        return ReadDouble($buffer_ref, $position_ref);
+    }
+    elsif ($type == Type->get_type('JavonetUnsignedLongLong')) {
+        return ReadULong($buffer_ref, $position_ref);
+    }
+    elsif ($type == Type->get_type('JavonetUnsignedInteger')) {
+        return ReadUInt($buffer_ref, $position_ref);
+    }
+    elsif ($type == Type->get_type('JavonetNull')) {
+        return ReadNull($buffer_ref, $position_ref);
+    }
+    else {
+        die "NotImplementedException: Type not supported: $type";
+    }
+}
+
+# ReadCommand
+sub ReadCommand {
+    my ($buffer_ref, $position_ref) = @_;
+    my @buffer = @$buffer_ref;
+    my $p = $$position_ref;
+    
+    # Read numberOfElements from bytes p+1 to p+4
+    my @int_buffer = @buffer[$p + 1 .. $p + 4];
+    my $numberOfElements = TypeDeserializer->deserializeInt(\@int_buffer);
+    
+    my $runtime = $buffer[$p + 5];
+    my $commandType = $buffer[$p + 6];
+    
+    $$position_ref += 7;
+    
+    # Read all payload elements at once
+    my @payload = ();
+    for (my $i = 0; $i < $numberOfElements; $i++) {
+        push @payload, ReadObject($buffer_ref, $position_ref);
+    }
+    
+    return PerlCommand->new(
+        runtime => $runtime,
+        command_type => $commandType,
+        payload => \@payload
+    );
+}
+
+# ReadString
+sub ReadString {
+    my ($buffer_ref, $position_ref) = @_;
+    my @buffer = @$buffer_ref;
+    my $p = $$position_ref;
+    
+    my $mode = $buffer[$p + 1];
+    my @int_buffer = @buffer[$p + 2 .. $p + 5];
+    my $size = TypeDeserializer->deserializeInt(\@int_buffer);
+    
+    $$position_ref += 6;
+    $p = $$position_ref;
+    $$position_ref += $size;
+    
+    my @string_buffer = @buffer[$p .. $p + $size - 1];
+    return TypeDeserializer->deserializeString($mode, \@string_buffer);
+}
+
+# ReadInt
+sub ReadInt {
+    my ($buffer_ref, $position_ref) = @_;
+    my @buffer = @$buffer_ref;
+    my $size = 4;
+    
+    $$position_ref += 2;
+    my $p = $$position_ref;
+    $$position_ref += $size;
+    
+    my @int_buffer = @buffer[$p .. $p + $size - 1];
+    return TypeDeserializer->deserializeInt(\@int_buffer);
+}
+
+# ReadBool 
+sub ReadBool {
+    my ($buffer_ref, $position_ref) = @_;
+    my @buffer = @$buffer_ref;
+    my $size = 1;
+    
+    $$position_ref += 2;
+    my $p = $$position_ref;
+    $$position_ref += $size;
+    
+    return TypeDeserializer->deserializeBool($buffer[$p]);
+}
+
+# ReadFloat 
+sub ReadFloat {
+    my ($buffer_ref, $position_ref) = @_;
+    my @buffer = @$buffer_ref;
+    my $size = 4;
+    
+    $$position_ref += 2;
+    my $p = $$position_ref;
+    $$position_ref += $size;
+    
+    my @float_buffer = @buffer[$p .. $p + $size - 1];
+    return TypeDeserializer->deserializeFloat(\@float_buffer);
+}
+
+# ReadByte 
+sub ReadByte {
+    my ($buffer_ref, $position_ref) = @_;
+    my @buffer = @$buffer_ref;
+    my $size = 1;
+    
+    $$position_ref += 2;
+    my $p = $$position_ref;
+    $$position_ref += $size;
+    
+    return TypeDeserializer->deserializeByte($buffer[$p]);
+}
+
+# ReadChar
+sub ReadChar {
+    my ($buffer_ref, $position_ref) = @_;
+    my @buffer = @$buffer_ref;
+    my $size = 1;
+    
+    $$position_ref += 2;
+    my $p = $$position_ref;
+    $$position_ref += $size;
+    
+    return TypeDeserializer->deserializeChar($buffer[$p]);
+}
+
+# ReadLong 
+sub ReadLong {
+    my ($buffer_ref, $position_ref) = @_;
+    my @buffer = @$buffer_ref;
+    my $size = 8;
+    
+    $$position_ref += 2;
+    my $p = $$position_ref;
+    $$position_ref += $size;
+    
+    my @longlong_buffer = @buffer[$p .. $p + $size - 1];
+    return TypeDeserializer->deserializeLongLong(\@longlong_buffer);
+}
+
+# ReadDouble 
+sub ReadDouble {
+    my ($buffer_ref, $position_ref) = @_;
+    my @buffer = @$buffer_ref;
+    my $size = 8;
+    
+    $$position_ref += 2;
+    my $p = $$position_ref;
+    $$position_ref += $size;
+    
+    my @double_buffer = @buffer[$p .. $p + $size - 1];
+    return TypeDeserializer->deserializeDouble(\@double_buffer);
+}
+
+# ReadULong 
+sub ReadULong {
+    my ($buffer_ref, $position_ref) = @_;
+    my @buffer = @$buffer_ref;
+    my $size = 8;
+    
+    $$position_ref += 2;
+    my $p = $$position_ref;
+    $$position_ref += $size;
+    
+    my @ulonglong_buffer = @buffer[$p .. $p + $size - 1];
+    return TypeDeserializer->deserializeULongLong(\@ulonglong_buffer);
+}
+
+# ReadUInt
+sub ReadUInt {
+    my ($buffer_ref, $position_ref) = @_;
+    my @buffer = @$buffer_ref;
+    my $size = 4;
+    
+    $$position_ref += 2;
+    my $p = $$position_ref;
+    $$position_ref += $size;
+    
+    my @uint_buffer = @buffer[$p .. $p + $size - 1];
+    return TypeDeserializer->deserializeUInt(\@uint_buffer);
+}
+
+# ReadNull 
+sub ReadNull {
+    my ($buffer_ref, $position_ref) = @_;
+    my @buffer = @$buffer_ref;
+    my $size = 1;
+    
+    $$position_ref += 2;
+    my $p = $$position_ref;
+    $$position_ref += $size;
+    
+    # Note: deserializeUndef doesn't use the buffer, but we match C# structure
+    return TypeDeserializer->deserializeUndef();
+}
+
 1;

data/lib/javonet-ruby-sdk/Binaries/Perl/Linux/X64/lib/Javonet/Core/Protocol/CommandSerializer.pm

@@ -8,81 +8,92 @@ use aliased 'Javonet::Sdk::Core::RuntimeLib' => 'RuntimeLib', qw(get_runtime);
 use aliased 'Javonet::Sdk::Core::Type' => 'Type', qw(get_type);
 use aliased 'Javonet::Core::Protocol::TypeSerializer' => 'TypeSerializer';
 use aliased 'Javonet::Sdk::Core::TypesHandler' => 'TypesHandler';
+use aliased 'Javonet::Core::Handler::ReferencesCache' => 'ReferencesCache';
+use aliased 'Javonet::Sdk::Core::PerlCommandType' => 'PerlCommandType';
 use Javonet::Sdk::Internal::ConnectionType;
-use Thread::Queue;
 
 use Exporter qw(import);
-our @EXPORT = qw(serialize serialize_tcp_address serialize_recursively insert_into_buffer);
-
-my @byte_buffer = ();
-my $queue = Thread::Queue->new();
+our @EXPORT = qw(serialize serialize_connection_data);
 
 sub serialize {
     my ($class, $root_command, $connection_type, $tcp_address, $runtimeVersion) = @_;
-    @byte_buffer = ();
-    $queue = Thread::Queue->new();
-    $queue->insert(0, $root_command);
-    $class->insert_into_buffer(($root_command->{runtime}, $runtimeVersion));
-    $class->insert_into_buffer($class->serialize_tcp_address($connection_type, $tcp_address));
-    $class->insert_into_buffer(Javonet::Sdk::Core::RuntimeLib::get_runtime('Perl'), $root_command->{command_type});
-    $class->serialize_recursively();
+    $runtimeVersion = 0 unless defined $runtimeVersion;
+    
+    # Local buffer instead of global
+    my @byte_buffer = ();
+    
+    # Helper to insert data into buffer
+    my $insert_into_buffer = sub {
+        my (@data) = @_;
+        push @byte_buffer, @data;
+    };
+    
+    # Write runtime and version
+    $insert_into_buffer->($root_command->{runtime}, $runtimeVersion);
+    
+    # Write connection data
+    my @connection_data = $class->serialize_connection_data($connection_type, $tcp_address);
+    $insert_into_buffer->(@connection_data);
+    
+    # Write runtime name and command type header for Perl runtime
+    $insert_into_buffer->(
+        Javonet::Sdk::Core::RuntimeLib::get_runtime('Perl'),
+        $root_command->{command_type}
+    );
+    
+    # Serialize payload recursively
+    $class->serialize_recursively($root_command, $insert_into_buffer);
+    
     return @byte_buffer;
 }
 
-sub serialize_tcp_address {
+sub serialize_connection_data {
     my ($class, $connection_type, $tcp_address) = @_;
-    my @tcp_byte_array;
-    if (Javonet::Sdk::Internal::ConnectionType::get_connection_type('Tcp') eq $connection_type) {
+    if (defined $connection_type && 
+        Javonet::Sdk::Internal::ConnectionType::get_connection_type('Tcp') eq $connection_type) {
         my @tcp_array = split(':', $tcp_address);
         my @tcp_ip = split('\\.', $tcp_array[0]);
         my @bytes_port = unpack "C*", pack "v", $tcp_array[1];
-        @tcp_byte_array = (Javonet::Sdk::Internal::ConnectionType::get_connection_type('Tcp'), @tcp_ip, @bytes_port);
-        return @tcp_byte_array;
+        return (Javonet::Sdk::Internal::ConnectionType::get_connection_type('Tcp'), @tcp_ip, @bytes_port);
     }
     else {
-        @tcp_byte_array = (Javonet::Sdk::Internal::ConnectionType::get_connection_type('InMemory'), 0, 0, 0, 0, 0, 0);
-        return @tcp_byte_array;
+        return (Javonet::Sdk::Internal::ConnectionType::get_connection_type('InMemory'), 0, 0, 0, 0, 0, 0);
     }
 }
 
+# Recursively serialize command payload - matches C# SerializeRecursively
 sub serialize_recursively {
-    my ($class) = @_;
-    my $left = $queue->pending();
-    if ($left == 0) {
-        return @byte_buffer;
-    }
-    my $command = $queue->dequeue();
-    $queue->insert(0, $command->drop_first_payload_argument());
-    my $current_payload_ref = $command->{payload};
-    my @cur_payload = @$current_payload_ref;
-    my $payload_len = @cur_payload;
-    if ($payload_len > 0) {
-        if (!defined $cur_payload[0]) {
-            $class->insert_into_buffer(TypeSerializer->serializePrimitive(undef));
+    my ($class, $command, $insert_into_buffer) = @_;
+    
+    my $payload_ref = $command->{payload};
+    my @payload = @$payload_ref;
+    
+    foreach my $item (@payload) {
+        if (defined $item && ref $item eq 'Javonet::Sdk::Core::PerlCommand') {
+            # Item is a Command - serialize it and recurse
+            my @command_bytes = TypeSerializer->serializeCommand($item);
+            $insert_into_buffer->(@command_bytes);
+            $class->serialize_recursively($item, $insert_into_buffer);
         }
-        elsif ($cur_payload[0]->isa("Javonet::Sdk::Core::PerlCommand")) {
-            my $inner_command = $cur_payload[0];
-            $class->insert_into_buffer(TypeSerializer->serializeCommand($inner_command));
-            $queue->insert(0, $inner_command);
-        }
-        elsif (TypesHandler->is_primitive_or_none($cur_payload[0])) {
-            my @result = TypeSerializer->serializePrimitive($cur_payload[0]);
-            $class->insert_into_buffer(@result);
+        elsif (TypesHandler->is_primitive_or_none($item)) {
+            # Item is primitive or null
+            my @primitive_bytes = TypeSerializer->serializePrimitive($item);
+            $insert_into_buffer->(@primitive_bytes);
         }
         else {
-            die "Unsupported payload item type: " . ref($cur_payload[0]) . " for payload item: $cur_payload[0].";
+            # Item is a reference - cache it and create a Reference command
+            my $reference_cache = ReferencesCache->new();
+            my $guid = $reference_cache->cache_reference($item);
+            my $reference_command = PerlCommand->new(
+                runtime => Javonet::Sdk::Core::RuntimeLib::get_runtime('Perl'),
+                command_type => PerlCommandType->get_command_type('Reference'),
+                payload => [$guid]
+            );
+            my @command_bytes = TypeSerializer->serializeCommand($reference_command);
+            $insert_into_buffer->(@command_bytes);
+            $class->serialize_recursively($reference_command, $insert_into_buffer);
         }
-        return $class->serialize_recursively();
     }
-    else {
-        $queue->dequeue();
-    }
-    return $class->serialize_recursively();
-}
-
-sub insert_into_buffer {
-    my ($class, @arguments) = @_;
-    @byte_buffer = (@byte_buffer, @arguments);
 }
 
 1;