javonet-ruby-sdk 2.6.10 → 2.6.11

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/handler/LoadLibraryHandler.php

@@ -15,7 +15,10 @@ use utils\exception\JavonetArgumentsMismatchException;
 final class LoadLibraryHandler extends AbstractHandler
 {
     private const REQUIRED_ARGUMENTS_COUNT = 1;
+    private const MAX_DIRECTORY_DEPTH = 10;
     private static array $loadedLibraries = [];
+    private static array $loadedAutoloaders = [];
+    private static array $registeredPsr4Autoloaders = [];
     private array $loadedClassPaths = [];
 
     public function process(CommandInterface $command): int
@@ -149,10 +152,117 @@ final class LoadLibraryHandler extends AbstractHandler
             throw new Exception(sprintf('PHP syntax error in file %s: %s', $realPath, $lastError['message']));
         }
 
+        // Try to find and load Composer autoloader before including the file
+        $this->findAndLoadComposerAutoloader($realPath);
+
         include_once $realPath;
         self::$loadedPhpFiles[] = $realPath;
     }
 
+    /**
+     * Searches for Composer autoloader in the directory hierarchy and loads it.
+     * Falls back to registering PSR-4 autoloader from composer.json if vendor/autoload.php is not available.
+     */
+    private function findAndLoadComposerAutoloader(string $filePath): void
+    {
+        $directory = dirname($filePath);
+
+        for ($i = 0; $i < self::MAX_DIRECTORY_DEPTH; $i++) {
+            $vendorAutoloader = $directory . DIRECTORY_SEPARATOR . 'vendor' . DIRECTORY_SEPARATOR . 'autoload.php';
+            $composerJson = $directory . DIRECTORY_SEPARATOR . 'composer.json';
+
+            // Prefer ready-made vendor autoloader
+            if (file_exists($vendorAutoloader)) {
+                $this->loadVendorAutoloader($vendorAutoloader);
+                return;
+            }
+
+            // Fallback: build autoloader from composer.json
+            if (file_exists($composerJson)) {
+                $this->registerAutoloaderFromComposerJson($composerJson, $directory);
+                return;
+            }
+
+            $parentDirectory = dirname($directory);
+            // Reached filesystem root
+            if ($parentDirectory === $directory) {
+                break;
+            }
+            $directory = $parentDirectory;
+        }
+    }
+
+    /**
+     * Loads vendor autoloader if not already loaded.
+     */
+    private function loadVendorAutoloader(string $autoloaderPath): void
+    {
+        $realAutoloaderPath = realpath($autoloaderPath);
+
+        if ($realAutoloaderPath === false) {
+            return;
+        }
+
+        // Don't load the same autoloader twice
+        if (in_array($realAutoloaderPath, self::$loadedAutoloaders, true)) {
+            return;
+        }
+
+        include_once $realAutoloaderPath;
+        self::$loadedAutoloaders[] = $realAutoloaderPath;
+    }
+
+    /**
+     * Registers PSR-4 autoloader based on composer.json configuration.
+     * This is a fallback when vendor/autoload.php is not available.
+     */
+    private function registerAutoloaderFromComposerJson(string $composerJsonPath, string $baseDir): void
+    {
+        $realComposerJsonPath = realpath($composerJsonPath);
+
+        if ($realComposerJsonPath === false) {
+            return;
+        }
+
+        // Don't register autoloader for the same composer.json twice
+        if (in_array($realComposerJsonPath, self::$registeredPsr4Autoloaders, true)) {
+            return;
+        }
+
+        $composerContent = file_get_contents($realComposerJsonPath);
+        if ($composerContent === false) {
+            return;
+        }
+
+        $composerConfig = json_decode($composerContent, true);
+        if ($composerConfig === null || !isset($composerConfig['autoload']['psr-4'])) {
+            return;
+        }
+
+        $psr4Map = $composerConfig['autoload']['psr-4'];
+        $realBaseDir = realpath($baseDir) ?: $baseDir;
+
+        spl_autoload_register(function (string $class) use ($psr4Map, $realBaseDir): void {
+            foreach ($psr4Map as $prefix => $path) {
+                $prefixLength = strlen($prefix);
+
+                if (strncmp($class, $prefix, $prefixLength) !== 0) {
+                    continue;
+                }
+
+                $relativeClass = substr($class, $prefixLength);
+                $file = $realBaseDir . DIRECTORY_SEPARATOR . $path . str_replace('\\', DIRECTORY_SEPARATOR, $relativeClass) . '.php';
+
+                if (file_exists($file)) {
+                    include_once $file;
+                    return;
+                }
+            }
+        });
+
+        self::$registeredPsr4Autoloaders[] = $realComposerJsonPath;
+    }
+
     private function autoloadPhpFilesFromDirectory(string $directory): void
     {
         $iterator = new RecursiveIteratorIterator(

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/interpreter/Interpreter.php

@@ -23,29 +23,30 @@ use utils\Uri;
 
 final class Interpreter
 {
-    private string $debugMode;
-    private Handler $handler;
+    private function __construct()
+    {
+    }
 
-    public function __construct()
+    private static function getDebugMode(): string
     {
-        $this->debugMode = getenv('DEBUG') !== false ? getenv('DEBUG') : 'FALSE';
-        $this->handler = new Handler();
+        return getenv('DEBUG') !== false ? getenv('DEBUG') : 'FALSE';
     }
 
-    public function execute(CommandInterface $command, IConnectionData $connectionData): CommandInterface
+    public static function execute(CommandInterface $command, IConnectionData $IConnectionData): CommandInterface
     {
-        if ($this->debugMode === 'TRUE') {
+        $debugMode = self::getDebugMode();
+        if ($debugMode === 'TRUE') {
             echo 'Sent command: ' . $command;
             MessageHelper::getInstance()->sendMessageToAppInsights('SentCommand', $command->toString());
         }
 
-        $responseByteArray = $this->getResponseByteArray($command, $connectionData);
+        $responseByteArray = self::getResponseByteArray($command, $IConnectionData);
         if ($responseByteArray instanceof Command) {
             return $responseByteArray;
         }
 
         $response = CommandDeserializer::deserialize($responseByteArray);
-        if ($this->debugMode === 'TRUE') {
+        if ($debugMode === 'TRUE') {
             echo 'Received command: ' . $response;
             MessageHelper::getInstance()->sendMessageToAppInsights('ReceivedCommand', $response->toString());
         }
@@ -53,13 +54,13 @@ final class Interpreter
         return $response;
     }
 
-    private function getResponseByteArray(Command $command, IConnectionData $connectionData)
+    private static function getResponseByteArray(Command $command, IConnectionData $IConnectionData)
     {
-        $messageByteArray = CommandSerializer::serialize($command, $connectionData);
-        if ($this->isWebSocket($connectionData))
+        $messageByteArray = CommandSerializer::serialize($command, $IConnectionData);
+        if (self::isWebSocket($IConnectionData))
         {
             try {
-                return WebSocketClient::sendMessage(new Uri($connectionData->getHostname()), $messageByteArray);
+                return WebSocketClient::sendMessage(new Uri($IConnectionData->getHostname()), $messageByteArray);
             } catch (Exception $e) {
                 if ($e->getPrevious() instanceof Throwable) {
                     return ExceptionSerializer::serializeException($e->getPrevious(), $command);
@@ -69,34 +70,35 @@ final class Interpreter
             }
         }
 
-        if ($this->isInMemoryAndSameRuntime($command, $connectionData)) {
-            return (new Receiver())->sendCommand($messageByteArray);
+        if (self::isInMemoryAndSameRuntime($command, $IConnectionData)) {
+            return Receiver::sendCommand($messageByteArray);
         }
 
         return Transmitter::sendCommand($messageByteArray);
     }
 
-    private function isWebSocket(IConnectionData $connectionData): bool
+    private static function isWebSocket(IConnectionData $IConnectionData): bool
     {
-        return $connectionData->getConnectionType()->equalsByValue(ConnectionType::WEB_SOCKET);
+        return $IConnectionData->getConnectionType()->equalsByValue(ConnectionType::WEB_SOCKET);
     }
 
-    private function isInMemoryAndSameRuntime(Command $command, IConnectionData $connectionData): bool
+    private static function isInMemoryAndSameRuntime(Command $command, IConnectionData $IConnectionData): bool
     {
         return $command->getRuntimeName()->equalsByValue(RuntimeName::PHP)
-            && $connectionData->getConnectionType()->equalsByValue(ConnectionType::IN_MEMORY);
+            && $IConnectionData->getConnectionType()->equalsByValue(ConnectionType::IN_MEMORY);
     }
 
-    public function process(array $byteArray): CommandInterface
+    public static function process(array $byteArray): CommandInterface
     {
+        $debugMode = self::getDebugMode();
         $receivedCommand = CommandDeserializer::deserialize($byteArray);
-        if ($this->debugMode === 'TRUE') {
+        if ($debugMode === 'TRUE') {
             echo 'Received command: ' . $receivedCommand;
             MessageHelper::getInstance()->sendMessageToAppInsights('ReceivedCommand', $receivedCommand->toString());
         }
 
-        $response = $this->handler->handleCommand($receivedCommand);
-        if ($this->debugMode === 'TRUE') {
+        $response = Handler::handleCommand($receivedCommand);
+        if ($debugMode === 'TRUE') {
             echo 'Response command: ' . $response;
             MessageHelper::getInstance()->sendMessageToAppInsights('ResponseCommand', $response->toString());
         }

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/protocol/CommandSerializer.php

@@ -27,7 +27,7 @@ final class CommandSerializer
      *
      * @return int[]
      */
-    public static function serialize(CommandInterface $rootCommand, ?IConnectionData $connectionData): array
+    public static function serialize(CommandInterface $rootCommand, ?IConnectionData $IConnectionData): array
     {
         try {
             $buffer = [];
@@ -37,7 +37,7 @@ final class CommandSerializer
             $buffer[] = 0; // runtimeVersion
 
             // Write connection data
-            self::insertIntoBuffer($buffer, self::getDataByConnectionData($connectionData));
+            self::insertIntoBuffer($buffer, self::getDataByIConnectionData($IConnectionData));
 
             // Write runtime name and command type header for PHP runtime
             self::insertIntoBuffer($buffer, [
@@ -61,10 +61,10 @@ final class CommandSerializer
     /**
      * @return int[]
      */
-    private static function getDataByConnectionData(?IConnectionData $connectionData): array
+    private static function getDataByIConnectionData(?IConnectionData $IConnectionData): array
     {
-        if ($connectionData !== null) {
-            return $connectionData->serializeConnectionData();
+        if ($IConnectionData !== null) {
+            return $IConnectionData->serializeConnectionData();
         }
 
         return self::DEFAULT_SERIALIZER_CONNECTION_DATA;

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/receiver/Receiver.php

@@ -17,11 +17,14 @@ use utils\type\CommandType;
 
 final class Receiver
 {
+    private function __construct()
+    {
+    }
 
-    public function sendCommand(array $messageByteArray): array
+    public static function sendCommand(array $messageByteArray): array
     {
         try {
-            $result = (new Interpreter())->process($messageByteArray);
+            $result = Interpreter::process($messageByteArray);
             return CommandSerializer::serialize($result, null);
         } catch (Throwable $ex) {
             $exceptionCommand = ExceptionSerializer::serializeException(
@@ -32,12 +35,12 @@ final class Receiver
         }
     }
 
-    public function heartBeat(array $messageByteArray): array
+    public static function heartBeat(array $messageByteArray): array
     {
         return [$messageByteArray[11], $messageByteArray[12] - 2];
     }
 
-    public function getRuntimeInfo(): string
+    public static function getRuntimeInfo(): string
     {
         return RuntimeLogger::getRuntimeInfo();
     }

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/utils/Command.php

@@ -14,18 +14,26 @@ final class Command implements CommandInterface
     /** @var array<mixed> */
     private array $payload;
 
+    /**
+     * Constructor with variadic parameters (params object[] payload in C#)
+     * Also handles Array payload case - if a single array is passed, treat it as the payload
+     */
     public function __construct(
         RuntimeName $runtimeName,
         CommandType $commandType,
-                    ...$payload
+        ...$payload
     ) {
         $this->runtimeName = $runtimeName;
         $this->commandType = $commandType;
-
-        // If a single array is passed, treat it as the payload itself.
-        if (count($payload) === 1 && is_array($payload[0])) {
+        
+        if ($payload === null || count($payload) === 0) {
+            $this->payload = [];
+        } elseif (count($payload) === 1 && is_array($payload[0])) {
+            // Single array passed - treat it as the payload itself (Array payload case in C#)
+            // Reuse array directly - no conversion overhead if it's already object[]
             $this->payload = $payload[0];
         } else {
+            // Multiple arguments or non-array - treat as variadic params
             $this->payload = $payload;
         }
     }
@@ -35,10 +43,19 @@ final class Command implements CommandInterface
      */
     public function addArgToPayload($arg): CommandInterface
     {
-        // Keep semantics (return new Command) but avoid array_merge overhead.
-        $newPayload = $this->payload;
-        $newPayload[] = $arg;
-
+        $oldLength = count($this->payload);
+        $newPayload = [];
+        
+        if ($oldLength > 0) {
+            // Copy existing payload
+            foreach ($this->payload as $item) {
+                $newPayload[] = $item;
+            }
+        }
+        
+        $newPayload[$oldLength] = $arg;
+        
+        // Pass as single array argument to match Array constructor pattern
         return new Command($this->runtimeName, $this->commandType, $newPayload);
     }
 
@@ -91,16 +108,29 @@ final class Command implements CommandInterface
     public function __toString(): string
     {
         try {
-            $result = 'RuntimeName: ';
+            $result = 'RuntimeName ';
             $result .= $this->runtimeName->getName();
-            $result .= ' CommandType: ';
+            $result .= ' ';
+            $result .= 'CommandType ';
             $result .= $this->commandType->getName();
-            $result .= ' Payload: ';
-            $result .= json_encode($this->payload);
-
+            $result .= ' ';
+            $result .= 'Payload ';
+            
+            $payload = $this->payload;
+            $len = count($payload);
+            
+            for ($i = 0; $i < $len; $i++) {
+                $item = $payload[$i];
+                $result .= ($item !== null ? (string)$item : 'null');
+                
+                if ($i < $len - 1) {
+                    $result .= ' ';
+                }
+            }
+            
             return $result;
         } catch (Exception $e) {
-            return 'Error while converting command to string: ' . $e->getMessage();
+            return 'Error while converting command to string:' . $e->getMessage();
         }
     }
 
@@ -128,11 +158,43 @@ final class Command implements CommandInterface
             return new self($this->runtimeName, $this->commandType, $this->payload);
         }
 
-        return new self(
-            $this->runtimeName,
-            $this->commandType,
-            [$currentCommand, ...$this->payload]
-        );
+        $oldLength = count($this->payload);
+        $newPayload = [];
+        
+        // Put new element at the front
+        $newPayload[0] = $currentCommand;
+        
+        if ($oldLength > 0) {
+            // Copy existing payload starting from index 1
+            foreach ($this->payload as $item) {
+                $newPayload[] = $item;
+            }
+        }
+        
+        // Pass as single array argument to match Array constructor pattern
+        return new self($this->runtimeName, $this->commandType, $newPayload);
+    }
+
+    /**
+     * Drop first payload argument and return new Command
+     */
+    public function dropFirstPayloadArg(): CommandInterface
+    {
+        $payloadLength = count($this->payload);
+        
+        if ($payloadLength <= 1) {
+            return new Command($this->runtimeName, $this->commandType);
+        }
+        
+        $newPayload = [];
+        
+        // Copy from index 1 to end
+        for ($i = 1; $i < $payloadLength; $i++) {
+            $newPayload[] = $this->payload[$i];
+        }
+        
+        // Pass as single array argument to match Array constructor pattern
+        return new Command($this->runtimeName, $this->commandType, $newPayload);
     }
 
     /**
@@ -148,16 +210,18 @@ final class Command implements CommandInterface
             return false;
         }
 
-        if ($this->runtimeName !== $element->runtimeName || $this->commandType !== $element->commandType) {
+        if ($this->runtimeName->getValue() !== $element->getRuntimeName()->getValue() || 
+            $this->commandType->getValue() !== $element->getCommandType()->getValue()) {
             return false;
         }
 
-        if (count($this->payload) !== count($element->payload)) {
+        $elementPayload = $element->getPayload();
+        if (count($this->payload) !== count($elementPayload)) {
             return false;
         }
 
         foreach ($this->payload as $index => $payloadItem) {
-            $elementPayloadItem = $element->payload[$index];
+            $elementPayloadItem = $elementPayload[$index];
 
             if ($payloadItem instanceof CommandInterface && $elementPayloadItem instanceof CommandInterface) {
                 if (!$payloadItem->equals($elementPayloadItem)) {

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/utils/DynamicMethodFactory.php

@@ -45,8 +45,7 @@ final class DynamicMethodFactory
                     $payload
                 );
 
-                $interpreter = new Interpreter();
-                $executeCall = $interpreter->execute(
+                $executeCall = Interpreter::execute(
                     $invokeDelegateCommand, 
                     new InMemoryConnectionData()
                 );

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/utils/ExceptionSerializer.php

@@ -27,7 +27,21 @@ final class ExceptionSerializer
         $exceptionName = basename(str_replace('\\', '/', get_class($exception)));
 
         $exceptionCommand = $exceptionCommand->addArgToPayload(ExceptionType::getExceptionCodeByExceptionName($exceptionName));
-        $exceptionCommand = $exceptionCommand->addArgToPayload((string)$command);
+        $commandString = '';
+        try {
+            if (is_string($command)) {
+                $commandString = $command;
+            } elseif (method_exists($command, '__toString')) {
+                $commandString = (string)$command;
+            } else {
+                $encoded = json_encode($command, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE);
+                $commandString = $encoded !== false ? $encoded : get_class($command);
+            }
+        } catch (\Throwable $e) {
+            $commandString = get_class($command);
+        }
+
+        $exceptionCommand = $exceptionCommand->addArgToPayload($commandString);
         $exceptionCommand = $exceptionCommand->addArgToPayload($exceptionName);
         $exceptionCommand = $exceptionCommand->addArgToPayload($exception->getMessage());
         $exceptionCommand = $exceptionCommand->addArgToPayload($stackClasses);

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/utils/RuntimeNameHandler.php

@@ -37,4 +37,36 @@ final class RuntimeNameHandler
                  throw new \Exception('Invalid runtime name.');
         }
     }
+
+    public static function getRuntimeName(string $runtime): RuntimeName
+    {
+        switch (strtolower($runtime)) {
+            case 'clr':
+                return new RuntimeName(RuntimeName::CLR);
+            case 'go':
+                return new RuntimeName(RuntimeName::GO);
+            case 'jvm':
+                return new RuntimeName(RuntimeName::JVM);
+            case 'netcore':
+                return new RuntimeName(RuntimeName::NETCORE);
+            case 'perl':
+                return new RuntimeName(RuntimeName::PERL);
+            case 'python':
+                return new RuntimeName(RuntimeName::PYTHON);
+            case 'ruby':
+                return new RuntimeName(RuntimeName::RUBY);
+            case 'nodejs':
+                return new RuntimeName(RuntimeName::NODEJS);
+            case 'cpp':
+                return new RuntimeName(RuntimeName::CPP);
+            case 'php':
+                return new RuntimeName(RuntimeName::PHP);
+            case 'python27':
+                return new RuntimeName(RuntimeName::PYTHON27);
+            case 'none':
+                return new RuntimeName(RuntimeName::NONE);
+            default:
+                 throw new \Exception('Invalid runtime name string.');
+        }
+    }
 }

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/utils/UtilsConst.php

@@ -28,9 +28,12 @@ final class UtilsConst
 
     public static function getJavonetWorkingDirectory(): string
     {
-         if (empty(self::$javonetWorkingDirectory)) {
-             return self::$javonetWorkingDirectory = dirname(__DIR__) . '/';
-         }
+        if (empty(self::$javonetWorkingDirectory)) {
+            $base = str_replace('\\', '/', dirname(__DIR__));
+            self::$javonetWorkingDirectory = rtrim($base, '/') . '/';
+        } else {
+            self::$javonetWorkingDirectory = rtrim(str_replace('\\', '/', self::$javonetWorkingDirectory), '/') . '/';
+        }
 
         return self::$javonetWorkingDirectory;
     }

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/utils/connectiondata/IConnectionData.php

@@ -12,4 +12,4 @@ interface IConnectionData
     public function getHostname(): string;
     public function serializeConnectionData(): array;
     public function toString(): string;
-}
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/utils/connectiondata/InMemoryConnectionData.php

@@ -32,4 +32,4 @@ final class InMemoryConnectionData implements IConnectionData
     {
         return $this->getHostname();
     }
-}
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/utils/connectiondata/TcpConnectionData.php

@@ -60,6 +60,11 @@ final class TcpConnectionData implements IConnectionData
         ];
     }
 
+    public function getPort(): int
+    {
+        return $this->port;
+    }
+
     public function toString(): string
     {
         return $this->ipAddress . ':' . $this->port;
@@ -69,4 +74,4 @@ final class TcpConnectionData implements IConnectionData
     {
         return $this->ipAddress . ':' . $this->port;
     }
-}
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/utils/connectiondata/WsConnectionData.php

@@ -40,4 +40,4 @@ final class WsConnectionData implements IConnectionData
     {
         return $this->hostName;
     }
-}
+}

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/core/callback/callbackFunc.py

@@ -3,10 +3,10 @@ from ctypes import *
 def callbackFunc(message_byte_array, message_byte_array_len):
     message_byte_array_py = bytearray((c_ubyte * message_byte_array_len).from_address(
         addressof(message_byte_array.contents)))
-    message_byte_array_len_py = int(message_byte_array_len)
     from javonet.core.receiver.Receiver import Receiver
-    python_receiver = Receiver()
+    # Initialize exception handler if not already done
+    Receiver.initialize_exception_handler()
     if message_byte_array[10] == 11:
-        return python_receiver.HeartBeat(message_byte_array_py, message_byte_array_len_py)
+        return Receiver.heart_beat(message_byte_array_py)
     else:
-        return python_receiver.SendCommand(message_byte_array_py, message_byte_array_len_py)
+        return Receiver.send_command(message_byte_array_py)