javonet-ruby-sdk 2.5.20 → 2.6.0

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

@@ -0,0 +1,66 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler\LoadLibrary;
+
+use Phar;
+
+final class ClasspathScanner
+{
+    public function getClassesFromFile(string $filePath): array
+    {
+        if (!is_file($filePath)) {
+            return [];
+        }
+
+        $classes = [];
+        if (substr($filePath, -5) === '.phar') {
+            return $this->getClassesFromPhar($filePath);
+        }
+
+        if (substr($filePath, -4) === '.php') {
+            $content = file_get_contents($filePath);
+            $classes = $this->extractClassesFromPhpContent($content);
+        }
+
+        return $classes;
+    }
+
+    private function getClassesFromPhar(string $pharPath): array
+    {
+        $classes = [];
+
+        $phar = new Phar($pharPath);
+        foreach ($phar as $file) {
+            if ($file->getExtension() === 'php') {
+                $content = $file->getContent();
+                $classes = array_merge(
+                    $classes,
+                    $this->extractClassesFromPhpContent($content)
+                );
+            }
+        }
+
+        return $classes;
+    }
+
+    private function extractClassesFromPhpContent(string $content): array
+    {
+        $classes = [];
+        $namespace = '';
+
+        if (preg_match('/namespace\s+([a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff\\\\]*)\s*;/', $content, $matches)) {
+            $namespace = $matches[1] . '\\';
+        }
+
+        preg_match_all('/(?:class|interface|trait)\s+([a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*)/i', $content, $matches);
+        
+        foreach ($matches[1] as $className) {
+            $fullClassName = $namespace . $className;
+            $classes[] = $fullClassName;
+        }
+
+        return $classes;
+    }
+}

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

@@ -0,0 +1,106 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\interpreter;
+
+use core\handler\Handler;
+use core\protocol\CommandDeserializer;
+use core\protocol\CommandSerializer;
+use core\receiver\Receiver;
+use core\transmitter\Transmitter;
+use core\webSocketClient\WebSocketClient;
+use Exception;
+use Throwable;
+use utils\Command;
+use utils\CommandInterface;
+use utils\connectiondata\IConnectionData;
+use utils\ExceptionSerializer;
+use utils\messagehelper\MessageHelper;
+use utils\RuntimeName;
+use utils\type\ConnectionType;
+use utils\Uri;
+
+final class Interpreter
+{
+    private string $debugMode;
+    private Handler $handler;
+
+    public function __construct()
+    {
+        $this->debugMode = getenv('DEBUG') !== false ? getenv('DEBUG') : 'FALSE';
+        $this->handler = new Handler();
+    }
+
+    public function execute(CommandInterface $command, IConnectionData $connectionData): CommandInterface
+    {
+        if ($this->debugMode === 'TRUE') {
+            echo 'Sent command: ' . $command;
+            MessageHelper::getInstance()->sendMessageToAppInsights('SentCommand', $command->toString());
+        }
+
+        $responseByteArray = $this->getResponseByteArray($command, $connectionData);
+        if ($responseByteArray instanceof Command) {
+            return $responseByteArray;
+        }
+
+        $response = (new CommandDeserializer($responseByteArray))->deserialize();
+        if ($this->debugMode === 'TRUE') {
+            echo 'Received command: ' . $response;
+            MessageHelper::getInstance()->sendMessageToAppInsights('ReceivedCommand', $response->toString());
+        }
+
+        return $response;
+    }
+
+    private function getResponseByteArray(Command $command, IConnectionData $connectionData)
+    {
+        $messageByteArray = CommandSerializer::serialize($command, $connectionData);
+        if ($this->isWebSocket($connectionData))
+        {
+            try {
+                return WebSocketClient::sendMessage(new Uri($connectionData->getHostname()), $messageByteArray);
+            } catch (Exception $e) {
+                if ($e->getPrevious() instanceof Throwable) {
+                    return ExceptionSerializer::serializeException($e->getPrevious(), $command);
+                }
+
+                return ExceptionSerializer::serializeException($e, $command);
+            }
+        }
+
+        if ($this->isInMemoryAndSameRuntime($command, $connectionData)) {
+            return (new Receiver())->sendCommand($messageByteArray);
+        }
+
+        return Transmitter::sendCommand($messageByteArray);
+    }
+
+    private function isWebSocket(IConnectionData $connectionData): bool
+    {
+        return $connectionData->getConnectionType()->equalsByValue(ConnectionType::WEB_SOCKET);
+    }
+
+    private function isInMemoryAndSameRuntime(Command $command, IConnectionData $connectionData): bool
+    {
+        return $command->getRuntimeName()->equalsByValue(RuntimeName::PHP)
+            && $connectionData->getConnectionType()->equalsByValue(ConnectionType::IN_MEMORY);
+    }
+
+    public function process(array $byteArray): CommandInterface
+    {
+        $receivedCommand = (new CommandDeserializer($byteArray))->deserialize();
+        if ($this->debugMode === 'TRUE') {
+            echo 'Received command: ' . $receivedCommand;
+            MessageHelper::getInstance()->sendMessageToAppInsights('ReceivedCommand', $receivedCommand->toString());
+        }
+
+        $response = $this->handler->handleCommand($receivedCommand);
+        if ($this->debugMode === 'TRUE') {
+            echo 'Response command: ' . $response;
+            MessageHelper::getInstance()->sendMessageToAppInsights('ResponseCommand', $response->toString());
+        }
+
+        return $response;
+    }
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/namespacescache/NamespacesCache.php

@@ -0,0 +1,88 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\namespacescache;
+
+use ReflectionClass;
+
+final class NamespacesCache
+{
+    private static ?NamespacesCache $instance = null;
+    private static array $namespacesCache = [];
+
+    private function __construct() {}
+
+    public static function getInstance(): NamespacesCache
+    {
+        if (self::$instance === null) {
+            self::$instance = new self();
+        }
+        return self::$instance;
+    }
+
+
+    public function cacheNamespace(string $namespaceRegex): void
+    {
+        self::$namespacesCache[] = $namespaceRegex;
+    }
+
+    public function isNamespaceCacheEmpty(): bool
+    {
+        return empty(self::$namespacesCache);
+    }
+
+    public function isTypeAllowed(object $typeToCheck): bool
+    {
+        $typeNamespace = $this->getTypeNamespace($typeToCheck);
+        foreach (self::$namespacesCache as $namespacePattern) {
+            if ($typeNamespace === $namespacePattern) {
+                return true;
+            }
+
+            $normalizedPattern = str_replace('\\', '.', $namespacePattern);
+            $normalizedNamespace = str_replace('\\', '.', $typeNamespace);
+
+            if (substr($normalizedPattern, -2) === '.*') {
+                $basePattern = substr($normalizedPattern, 0, -2);
+                if ($normalizedNamespace === $basePattern || strpos($normalizedNamespace, $basePattern . '.') === 0) {
+                    return true;
+                }
+            }
+
+            if (substr($normalizedPattern, -1) === '*') {
+                $basePattern = substr($normalizedPattern, 0, -1);
+                if ($normalizedNamespace === $basePattern || strpos($normalizedNamespace, $basePattern) === 0) {
+                    return true;
+                }
+            }
+
+            if ($normalizedNamespace === $normalizedPattern) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private function getTypeNamespace(object $typeToCheck): string
+    {
+        if ($typeToCheck instanceof ReflectionClass) {
+
+            return $typeToCheck->getNamespaceName();
+        }
+        $reflection = new ReflectionClass($typeToCheck);
+
+        return $reflection->getNamespaceName();
+    }
+
+    public function getCachedNamespaces(): array
+    {
+        return self::$namespacesCache;
+    }
+
+    public function clearCache(): void
+    {
+        self::$namespacesCache = [];
+    }
+}

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

@@ -0,0 +1,211 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\protocol;
+
+use utils\Command;
+use utils\CommandInterface;
+use utils\exception\TypeByteNotSupportedException;
+use utils\RuntimeName;
+use utils\StringEncodingMode;
+use utils\type\CommandType;
+use utils\type\JType;
+
+final class CommandDeserializer
+{
+    private int $position;
+    private Command $command;
+    private array $buffer;
+
+    public function __construct(
+         array $buffer
+    ) {
+        $this->command = new Command(
+            new RuntimeName($buffer[0]),
+            new CommandType($buffer[10])
+        );
+        $this->buffer = $buffer;
+        $this->position = 11;
+    }
+
+    private function isNotEnd(): bool
+    {
+        return $this->position < count($this->buffer);
+    }
+
+    public function deserialize(): CommandInterface
+    {
+        while ($this->isNotEnd()) {
+            $this->command = $this->command->addArgToPayload($this->readObject($this->buffer[$this->position]));
+        }
+
+        return $this->command;
+    }
+
+    private function readObject(int $typeNum)
+    {
+        $typeByte = new JType($typeNum);
+
+        switch ($typeByte->getValue()) {
+            case JType::JAVONET_COMMAND:
+                return $this->readCommand();
+            case JType::JAVONET_STRING:
+                return $this->readString();
+            case JType::JAVONET_INTEGER:
+                return $this->readInt();
+            case JType::JAVONET_BOOLEAN:
+                return $this->readBool();
+            case JType::JAVONET_FLOAT:
+                return $this->readFloat();
+            case JType::JAVONET_BYTE:
+                return $this->readByte();
+            case JType::JAVONET_CHAR:
+                return $this->readChar();
+            case JType::JAVONET_LONG:
+                return $this->readLong();
+            case JType::JAVONET_DOUBLE:
+                return $this->readDouble();
+            case JType::JAVONET_UNSIGNED_LONG_LONG:
+                return $this->readUnsignedLong();
+            case JType::JAVONET_UNSIGNED_INTEGER:
+                return $this->readUnsignedInteger();
+            case JType::JAVONET_NULL:
+                return $this->readNull();
+            default:
+                throw new TypeByteNotSupportedException($typeNum);
+        }
+    }
+
+    protected function readCommand(): CommandInterface
+    {
+        $p = $this->position;
+        $numberOfElementsInPayload = TypeDeserializer::deserializeInt(array_slice($this->buffer, $p + 1, 4));
+        $runtime = $this->buffer[$p + 5];
+        $commandType = $this->buffer[$p + 6];
+
+        $this->position += 7;
+
+        $payload = [];
+        for ($i = 0; $i < $numberOfElementsInPayload; $i++) {
+            $payload[$i] = $this->readObject($this->buffer[$this->position]);
+        }
+
+        return new Command(
+            new RuntimeName($runtime),
+            new CommandType($commandType),
+            $payload
+        );
+    }
+
+    private function readString(): string
+    {
+        $p = $this->position;
+        $stringEncodingMode = new StringEncodingMode($this->buffer[$p + 1]);
+        $size = TypeDeserializer::deserializeInt(array_slice($this->buffer, $p + 2, 4));
+        $this->position += 6;
+        $p = $this->position;
+        $this->position += $size;
+
+        return TypeDeserializer::deserializeString($stringEncodingMode, array_slice($this->buffer, $p, $size));
+    }
+
+    private function readInt(): int
+    {
+        $size = 4;
+        $this->position += 2;
+        $p = $this->position;
+        $this->position += $size;
+
+        return TypeDeserializer::deserializeInt(array_slice($this->buffer, $p, $size));
+    }
+
+    private function readBool(): bool
+    {
+        $size = 1;
+        $this->position += 2;
+        $p = $this->position;
+        $this->position += $size;
+
+        return TypeDeserializer::deserializeBool(array_slice($this->buffer, $p, $size));
+    }
+
+    private function readFloat(): float
+    {
+        $size = 4;
+        $this->position += 2;
+        $p = $this->position;
+        $this->position += $size;
+
+        return TypeDeserializer::deserializeFloat(array_slice($this->buffer, $p, $size));
+    }
+
+    private function readByte(): int
+    {
+        $size = 1;
+        $this->position += 2;
+        $p = $this->position;
+        $this->position += $size;
+
+        return TypeDeserializer::deserializeByte($this->buffer[$p]);
+    }
+
+    private function readChar(): string
+    {
+        $size = 1;
+        $this->position += 2;
+        $p = $this->position;
+        $this->position += $size;
+
+        return TypeDeserializer::deserializeChar($this->buffer[$p]);
+    }
+
+    private function readLong(): int
+    {
+        $size = 8;
+        $this->position += 2;
+        $p = $this->position;
+        $this->position += $size;
+
+        return TypeDeserializer::deserializeLong(array_slice($this->buffer, $p, $size));
+    }
+
+    private function readDouble(): float
+    {
+        $size = 8;
+        $this->position += 2;
+        $p = $this->position;
+        $this->position += $size;
+
+        return TypeDeserializer::deserializeDouble(array_slice($this->buffer, $p, $size));
+    }
+
+    private function readUnsignedLong(): int
+    {
+        $size = 8;
+        $this->position += 2;
+        $p = $this->position;
+        $this->position += $size;
+
+        return TypeDeserializer::deserializeLong(array_slice($this->buffer, $p, $size));
+    }
+
+    private function readUnsignedInteger(): int
+    {
+        $size = 4;
+        $this->position += 2;
+        $p = $this->position;
+        $this->position += $size;
+
+        return TypeDeserializer::deserializeInt(array_slice($this->buffer, $p, $size));
+    }
+
+    private function readNull()
+    {
+        $size = 1;
+        $this->position += 2;
+        $this->position += $size;
+
+        return TypeDeserializer::deserializeNull();
+    }
+}

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

@@ -0,0 +1,70 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\protocol;
+
+use core\referencecache\ReferencesCache;
+use Exception;
+use RuntimeException;
+use utils\Command;
+use utils\CommandInterface;
+use utils\connectiondata\IConnectionData;
+use utils\RuntimeName;
+use utils\type\CommandType;
+use utils\TypesHandler;
+
+final class CommandSerializer
+{
+    private function __construct()
+    {
+    }
+
+    private const DEFAULT_SERIALIZER_CONNECTION_DATA = [0, 0, 0, 0, 0, 0, 0];
+
+    public static function serialize(CommandInterface $rootCommand, ?IConnectionData $connectionData): array
+    {
+        try {
+            $buffer[] = $rootCommand->getRuntimeName()->getValue();
+            $buffer[] = 0; // runtimeVersion
+            array_push($buffer, ...self::getDataByConnectionData($connectionData));
+            $buffer[] = RuntimeName::PHP;
+            $buffer[] = $rootCommand->getCommandType()->getValue();
+
+            self::serializeRecursively($rootCommand, $buffer);
+
+            return $buffer;
+        } catch (Exception $e) {
+            throw new RuntimeException('Error during serialization ' . $e);
+        }
+    }
+
+    private static function getDataByConnectionData(?IConnectionData $connectionData): array
+    {
+        if (null !== $connectionData) {
+            return $connectionData->serializeConnectionData();
+        }
+
+        return self::DEFAULT_SERIALIZER_CONNECTION_DATA;
+    }
+
+    private static function serializeRecursively(CommandInterface $command, array &$buffer): void
+    {
+        foreach ($command->getPayload() as $payloadItem) {
+            if ($payloadItem instanceof CommandInterface) {
+                array_push($buffer, ...TypeSerializer::serializeCommand($payloadItem));
+                self::serializeRecursively($payloadItem, $buffer);
+            } else if (TypesHandler::isSimpleType($payloadItem)) {
+                array_push($buffer, ...TypeSerializer::serializePrimitive($payloadItem));
+            } else {
+                $refCommand = new Command(
+                    $command->getRuntimeName(),
+                    CommandType::REFERENCE(),
+                    ReferencesCache::getInstance()->cacheReference($payloadItem)
+                );
+                array_push($buffer, ...TypeSerializer::serializeCommand($refCommand));
+                self::serializeRecursively($refCommand, $buffer);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,95 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\protocol;
+
+use utils\StringEncodingMode;
+
+final class TypeDeserializer
+{
+    private function __construct()
+    {
+    }
+
+    public static function deserializeString(StringEncodingMode $stringEncodingMode, array $bytes): string
+    {
+        switch ($stringEncodingMode->getValue()) {
+            case StringEncodingMode::JAVONET_ASCII:
+                return mb_convert_encoding(pack("C*", ...$bytes), 'ASCII');
+            case StringEncodingMode::JAVONET_UTF8:
+                return mb_convert_encoding(pack("C*", ...$bytes), 'UTF-8');
+            case StringEncodingMode::JAVONET_UTF16:
+                return mb_convert_encoding(pack("C*", ...$bytes), 'UTF-16LE');
+            case StringEncodingMode::JAVONET_UTF32:
+                return mb_convert_encoding(pack("C*", ...$bytes), 'UTF-32LE');
+            default: # Default to UTF-8 for unknown encoding modes
+                return mb_convert_encoding(pack("C*", ...$bytes), 'UTF-8');
+        }
+    }
+
+    public static function deserializeInt(array $bytes): int
+    {
+        $int = ($bytes[0] & 0xFF)
+            | (($bytes[1] & 0xFF) << 8)
+            | (($bytes[2] & 0xFF) << 16)
+            | (($bytes[3] & 0xFF) << 24);
+
+        return $int & 0x80000000 ? $int - 0x100000000 : $int;
+    }
+
+    public static function deserializeBool(array $bytes): bool
+    {
+        return $bytes[0] === 1;
+    }
+
+    public static function deserializeFloat(array $bytes): float
+    {
+        return (float) substr(
+            number_format(
+                unpack(
+            'f',
+                    pack(
+                        'l',
+                        self::deserializeInt($bytes)
+                    )
+                )[1],
+                7, '.', ''),
+            0, -1
+        );
+    }
+
+    public static function deserializeByte(int $byteVal): int
+    {
+        return $byteVal & 0xFF;
+    }
+
+    public static function deserializeChar(int $byteVal): string
+    {
+        return chr($byteVal & 0xFF);
+    }
+
+    public static function deserializeLong(array $bytes): int
+    {
+        return (($bytes[0] & 0xFF)
+            | (($bytes[1] & 0xFF) << 8)
+            | (($bytes[2] & 0xFF) << 16)
+            | (($bytes[3] & 0xFF) << 24)
+            | (($bytes[4] & 0xFF) << 32)
+            | (($bytes[5] & 0xFF) << 40)
+            | (($bytes[6] & 0xFF) << 48)
+            | (($bytes[7] & 0xFF) << 56));
+    }
+
+    public static function deserializeDouble(array $bytes): float
+    {
+        return unpack('d',
+            pack('P', self::deserializeLong($bytes))
+        )[1];
+    }
+
+    public static function deserializeNull()
+    {
+        return null;
+    }
+}