javonet-ruby-sdk 2.6.10 → 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/Handler/PerlHandler.pm

@@ -135,7 +135,7 @@ Javonet::Core::Handler::HandlerDictionary::add_handler_to_dict(
 );
 
 sub handle_command {
-    my ($self, $command) = @_;
+    my ($class, $command) = @_;
     my $response = Javonet::Core::Handler::HandlerDictionary::get_handler($command->{command_type})->handle_command($command);
 
     if (TypesHandler->is_primitive_or_none($response)) {

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

@@ -9,13 +9,8 @@ use aliased 'Javonet::Core::Protocol::CommandDeserializer' => 'CommandDeserializ
 use Exporter qw(import);
 our @EXPORT = qw(execute_ process);
 
-my $handler = PerlHandler->new();
-
 sub execute_ {
-    my $self = shift;
-    my $command = shift;
-    my $connection_type = shift;
-    my $tcp_address = shift;
+    my ($class, $command, $connection_type, $tcp_address) = @_;
     my @serialized_command = Javonet::Core::Protocol::CommandSerializer->serialize($command, $connection_type, $tcp_address, 0);
     my $response_byte_array_ref;
     if ($command->{runtime} eq Javonet::Sdk::Core::RuntimeLib::get_runtime('Perl')) {
@@ -26,18 +21,15 @@ sub execute_ {
         $response_byte_array_ref = Javonet::Core::Transmitter::PerlTransmitter->t_send_command(\@serialized_command);
     }
 
-    my $commandDeserializer = CommandDeserializer->new($response_byte_array_ref);
-    return $commandDeserializer->decode();
+    return CommandDeserializer->deserialize($response_byte_array_ref);
 }
 
 sub process {
-    my ($self, $message_byte_array_ref) = @_;
+    my ($class, $message_byte_array_ref) = @_;
     my @message_byte_array = @$message_byte_array_ref;
-    my $commandDeserializer = CommandDeserializer->new(\@message_byte_array);
-    my $command = $commandDeserializer->decode();
-    my $response = $handler->handle_command($command);
-    my $commandSerializer = CommandSerializer->new();
-    my @response_byte_array = $commandSerializer->serialize($response, 0, 0, 0);
+    my $command = CommandDeserializer->deserialize(\@message_byte_array);
+    my $response = PerlHandler->handle_command($command);
+    my @response_byte_array = CommandSerializer->serialize($response, 0, 0, 0);
     return @response_byte_array;
 }
 

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

@@ -1,204 +1,266 @@
 package Javonet::Core::Protocol::CommandDeserializer;
 use strict;
 use warnings;
-use Moose;
 use lib 'lib';
 use aliased 'Javonet::Sdk::Core::PerlCommand' => 'PerlCommand';
 use aliased 'Javonet::Sdk::Core::Type' => 'Type', qw(get_type);
 use aliased 'Javonet::Core::Protocol::TypeDeserializer' => 'TypeDeserializer';
 
 use Exporter qw(import);
-our @EXPORT = qw(new isAtEnd decode readObject readCommand readCommandRecursively readString readInt readBool readFloat readByte readChar readLongLong readDouble readUnsignedLongLong readUnsignedInt readUndef);
-
-our $position = 0;
-our @buffer = [];
-our $command;
-
-sub new {
-    my ($self, $array_ref) = @_;
-    @buffer = @$array_ref;
-    $command = PerlCommand->new(runtime => $buffer[0],
-        command_type                    => $buffer[10], payload => []);
-    $position = 11;
-    return $self;
-}
-
-sub isAtEnd {
-    my $length = @buffer;
-    return $position == $length;
-}
+our @EXPORT = qw(deserialize);
 
-sub decode {
-    while (!isAtEnd()) {
-        $command = $command->addArgumentToPayload([ readObject($buffer[$position]) ]);
+# 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 => []
+    );
+    
+    # Use position reference to simulate ref parameter
+    my $position_ref = \$position;
+    
+    while ($position < @buffer) {
+        $command = $command->AddArgToPayload(ReadObject(\@buffer, $position_ref));
     }
+    
     return $command;
 }
 
-sub readObject {
-    my $type_num = $_[0];
-    if ($type_num == Type->get_type('Command')) {
-        return readCommand();
+# 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_num == Type->get_type('JavonetString')) {
-        return readString();
+    elsif ($type == Type->get_type('JavonetString')) {
+        return ReadString($buffer_ref, $position_ref);
     }
-    elsif ($type_num == Type->get_type('JavonetInteger')) {
-        return readInt();
+    elsif ($type == Type->get_type('JavonetInteger')) {
+        return ReadInt($buffer_ref, $position_ref);
     }
-    elsif ($type_num == Type->get_type('JavonetBool')) {
-        return readBool();
+    elsif ($type == Type->get_type('JavonetBool')) {
+        return ReadBool($buffer_ref, $position_ref);
     }
-    elsif ($type_num == Type->get_type('JavonetFloat')) {
-        return readFloat();
+    elsif ($type == Type->get_type('JavonetFloat')) {
+        return ReadFloat($buffer_ref, $position_ref);
     }
-    elsif ($type_num == Type->get_type('JavonetByte')) {
-        return readByte();
+    elsif ($type == Type->get_type('JavonetByte')) {
+        return ReadByte($buffer_ref, $position_ref);
     }
-    elsif ($type_num == Type->get_type('JavonetChar')) {
-        return readChar();
+    elsif ($type == Type->get_type('JavonetChar')) {
+        return ReadChar($buffer_ref, $position_ref);
     }
-    elsif ($type_num == Type->get_type('JavonetLongLong')) {
-        return readLongLong();
+    elsif ($type == Type->get_type('JavonetLongLong')) {
+        return ReadLong($buffer_ref, $position_ref);
     }
-    elsif ($type_num == Type->get_type('JavonetDouble')) {
-        return readDouble();
+    elsif ($type == Type->get_type('JavonetDouble')) {
+        return ReadDouble($buffer_ref, $position_ref);
     }
-    elsif ($type_num == Type->get_type('JavonetUnsignedLongLong')) {
-        return readUnsignedLongLong();
+    elsif ($type == Type->get_type('JavonetUnsignedLongLong')) {
+        return ReadULong($buffer_ref, $position_ref);
     }
-    elsif ($type_num == Type->get_type('JavonetUnsignedInteger')) {
-        return readUnsignedInt();
+    elsif ($type == Type->get_type('JavonetUnsignedInteger')) {
+        return ReadUInt($buffer_ref, $position_ref);
     }
-    elsif ($type_num == Type->get_type('JavonetNull')) {
-        return readUndef();
+    elsif ($type == Type->get_type('JavonetNull')) {
+        return ReadNull($buffer_ref, $position_ref);
     }
     else {
-        die "Type is not supported: $type_num";
+        die "NotImplementedException: Type not supported: $type";
     }
 }
 
-sub readCommand {
-    my $p = $position;
+# 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 $numberOfArgumentInPayload = TypeDeserializer->deserializeInt(\@int_buffer);
+    my $numberOfElements = 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);
-}
-
-sub readCommandRecursively {
-    my $numberOfArgumentInPayloadLeft = $_[0];
-    my $cmd = $_[1];
-
-    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->addArgumentToPayload([ readObject($buffer[$p]) ]);
-        return readCommandRecursively($numberOfArgumentInPayloadLeft - 1, $cmd);
+    
+    $$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
+    );
 }
 
-sub readString {
-    my $p = $position;
-    my $string_encoding_mode = $buffer[$p + 1];
+# 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 += 6;
-    $p = $position;
-    $position += $size;
+    
+    $$position_ref += 6;
+    $p = $$position_ref;
+    $$position_ref += $size;
+    
     my @string_buffer = @buffer[$p .. $p + $size - 1];
-    my $decodedString = TypeDeserializer->deserializeString($string_encoding_mode, \@string_buffer);
-
-    return $decodedString
+    return TypeDeserializer->deserializeString($mode, \@string_buffer);
 }
 
-sub readInt {
-    $position += 2;
-    my $p = $position;
-    $position += 4;
-    my @int_buffer = @buffer[$p .. $p + 3];
+# 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);
 }
 
-sub readBool {
-    $position += 2;
-    my $p = $position;
-    $position += 1;
-    my $bool_buffer = $buffer[$p];
-    return TypeDeserializer->deserializeBool($bool_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]);
 }
 
-sub readFloat {
-    $position += 2;
-    my $p = $position;
-    $position += 4;
-    my @float_buffer = @buffer[$p .. $p + 3];
+# 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);
 }
 
-sub readByte {
-    $position += 2;
-    my $p = $position;
-    $position += 1;
-    my $byte_buffer = $buffer[$p];
-    return TypeDeserializer->deserializeByte($byte_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]);
 }
 
-sub readChar {
-    $position += 2;
-    my $p = $position;
-    $position += 1;
-    my $char_buffer = $buffer[$p];
-    return TypeDeserializer->deserializeChar($char_buffer);
+# 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]);
 }
 
-sub readLongLong {
-    $position += 2;
-    my $p = $position;
-    $position += 8;
-    my @longlong_buffer = @buffer[$p .. $p + 7];
+# 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);
 }
 
-sub readDouble {
-    $position += 2;
-    my $p = $position;
-    $position += 8;
-    my @double_buffer = @buffer[$p .. $p + 7];
+# 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);
 }
 
-sub readUnsignedLongLong {
-    $position += 2;
-    my $p = $position;
-    $position += 8;
-    my @ulonglong_buffer = @buffer[$p .. $p + 7];
+# 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);
 }
 
-sub readUnsignedInt {
-    $position += 2;
-    my $p = $position;
-    $position += 4;
-    my @uint_buffer = @buffer[$p .. $p + 3];
+# 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);
 }
 
-sub readUndef {
-    $position += 2;
-    my $p = $position;
-    $position += 1;
-    my $undef_buffer = $buffer[$p];
-    return TypeDeserializer->deserializeUndef($undef_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();
 }
 
-no Moose;
 1;

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

@@ -1,7 +1,6 @@
 package Javonet::Core::Protocol::CommandSerializer;
 use strict;
 use warnings FATAL => 'all';
-use Moose;
 
 use lib 'lib';
 use aliased 'Javonet::Sdk::Core::PerlCommand' => 'PerlCommand';
@@ -9,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 ($self, $root_command, $connection_type, $tcp_address, $runtimeVersion) = @_;
-    @byte_buffer = ();
-    $queue = Thread::Queue->new();
-    $queue->insert(0, $root_command);
-    insert_into_buffer(($root_command->{runtime}, $runtimeVersion));
-    insert_into_buffer(serialize_tcp_address($connection_type, $tcp_address));
-    insert_into_buffer(Javonet::Sdk::Core::RuntimeLib::get_runtime('Perl'), $root_command->{command_type});
-    serialize_recursively();
+    my ($class, $root_command, $connection_type, $tcp_address, $runtimeVersion) = @_;
+    $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 {
-    my ($connection_type, $tcp_address) = @_;
-    my @tcp_byte_array;
-    if (Javonet::Sdk::Internal::ConnectionType::get_connection_type('Tcp') eq $connection_type) {
+sub serialize_connection_data {
+    my ($class, $connection_type, $tcp_address) = @_;
+    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 $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]) {
-            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];
-            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]);
-            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 serialize_recursively();
     }
-    else {
-        $queue->dequeue();
-    }
-    return serialize_recursively();
-}
-
-sub insert_into_buffer {
-    my @arguments = @_;
-    @byte_buffer = (@byte_buffer, @arguments);
 }
 
-no Moose;
 1;