javonet-ruby-sdk 2.5.20 → 2.6.0

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

@@ -0,0 +1,189 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\protocol;
+
+use utils\Command;
+use utils\exception\TypeSerializationNotSupportedException;
+use utils\StringEncodingMode;
+use utils\type\{
+    JType,
+    SizeType
+};
+use utils\UtilsSimpleType;
+
+final class TypeSerializer
+{
+    private function __construct()
+    {
+    }
+
+    /**
+     * @param mixed $value
+     */
+    public static function serializePrimitive($value): array
+    {
+        if (is_null($value)) {
+            return self::serializeNull();
+        }
+
+        if (UtilsSimpleType::isChar($value)) {
+            return self::serializeChar($value);
+        }
+
+        if (is_string($value)) {
+            return self::serializeString($value);
+        }
+
+        if (is_bool($value)) {
+            return self::serializeBool($value);
+        }
+
+        if (is_float($value)) {
+            return self::serializeDouble($value);
+        }
+
+        if (UtilsSimpleType::isFloat($value)) {
+            return self::serializeFloat($value);
+        }
+
+        if (UtilsSimpleType::isInteger($value)) {
+            return self::serializeInt($value);
+        }
+
+        if (UtilsSimpleType::isByte($value)) {
+            return self::serializeByte($value);
+        }
+
+        if (UtilsSimpleType::isLong($value)) {
+            return self::serializeLong($value);
+        }
+
+        throw new TypeSerializationNotSupportedException($value);
+    }
+
+    public static function serializeNull(): array
+    {
+        return [
+            JType::JAVONET_NULL,
+            SizeType::JAVONET_NULL_SIZE,
+            0
+        ];
+    }
+
+    public static function serializeString(string $val): array
+    {
+        $bytes = unpack('C*',mb_convert_encoding($val, 'UTF-8'));
+        $buffer[] = JType::JAVONET_STRING;
+        $buffer[] = StringEncodingMode::JAVONET_UTF8;
+        array_push($buffer, ...self::serializeIntValue(count($bytes)));
+
+        return array_merge($buffer, $bytes);
+    }
+
+    public static function serializeInt(int $intVal): array
+    {
+        return [
+            JType::JAVONET_INTEGER,
+            SizeType::JAVONET_INTEGER_SIZE,
+            $intVal & 0xFF,
+            ($intVal >> 8) & 0xFF,
+            ($intVal >> 16) & 0xFF,
+            ($intVal >> 24) & 0xFF
+        ];
+    }
+
+    public static function serializeBool(bool $boolValue): array
+    {
+        return [
+            JType::JAVONET_BOOLEAN,
+            SizeType::JAVONET_BOOLEAN_SIZE,
+            $boolValue ? 1 : 0
+        ];
+    }
+
+    public static function serializeFloat(float $floatValue): array
+    {
+        $bytesFloat = unpack('l', pack('f', $floatValue))[1];
+        return [
+            JType::JAVONET_FLOAT,
+            SizeType::JAVONET_FLOAT_SIZE,
+            $bytesFloat & 0xFF,
+            ($bytesFloat >> 8) & 0xFF,
+            ($bytesFloat >> 16) & 0xFF,
+            ($bytesFloat >> 24) & 0xFF
+        ];
+    }
+
+    public static function serializeByte(int $byteValue): array
+    {
+        return [
+            JType::JAVONET_BYTE,
+            SizeType::JAVONET_BYTE_SIZE,
+            $byteValue & 0xFF
+        ];
+    }
+
+    public static function serializeChar(string $charValue): array
+    {
+        return [
+            JType::JAVONET_CHAR,
+            SizeType::JAVONET_CHAR_SIZE,
+            ord($charValue)
+        ];
+    }
+
+    public static function serializeLong(int $longValue): array
+    {
+        return [
+            JType::JAVONET_LONG,
+            SizeType::JAVONET_LONG_SIZE,
+            $longValue & 0xFF,
+            ($longValue >> 8) & 0xFF,
+            ($longValue >> 16) & 0xFF,
+            ($longValue >> 24) & 0xFF,
+            ($longValue >> 32) & 0xFF,
+            ($longValue >> 40) & 0xFF,
+            ($longValue >> 48) & 0xFF,
+            ($longValue >> 56) & 0xFF,
+        ];
+    }
+
+    public static function serializeDouble(float $doubleValue): array
+    {
+        $value = unpack('P', pack('d', $doubleValue))[1];
+        return [
+            JType::JAVONET_DOUBLE,
+            SizeType::JAVONET_DOUBLE_SIZE,
+            $value & 0xFF,
+            ($value >> 8) & 0xFF,
+            ($value >> 16) & 0xFF,
+            ($value >> 24) & 0xFF,
+            ($value >> 32) & 0xFF,
+            ($value >> 40) & 0xFF,
+            ($value >> 48) & 0xFF,
+            ($value >> 56) & 0xFF,
+        ];
+    }
+
+    private static function serializeIntValue(int $intValue): array
+    {
+        return [
+            $intValue & 0xFF,
+            ($intValue >> 8) & 0xFF,
+            ($intValue >> 16) & 0xFF,
+            ($intValue >> 24) & 0xFF
+        ];
+    }
+
+    public static function serializeCommand(Command $cmd): array
+    {
+        $buffer[] = JType::JAVONET_COMMAND;
+        array_push($buffer, ...self::serializeIntValue($cmd->getPayloadSize()));
+        $buffer[] = $cmd->getRuntimeName()->getValue();
+        $buffer[] = $cmd->getCommandType()->getValue();
+
+        return $buffer;
+    }
+}

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

@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\receiver;
+
+use core\interpreter\Interpreter;
+use core\protocol\CommandSerializer;
+use utils\connectiondata\IConnectionData;
+use utils\connectiondata\InMemoryConnectionData;
+use utils\RuntimeLogger;
+
+final class Receiver
+{
+    private IConnectionData $connectionData;
+
+    public function __construct()
+    {
+        $this->connectionData = new InMemoryConnectionData();
+    }
+
+    public function sendCommand(array $messageByteArray): array
+    {
+        return CommandSerializer::serialize((new Interpreter())->process($messageByteArray), $this->connectionData);
+    }
+
+    public function heartBeat(array $messageByteArray): array
+    {
+        return [$messageByteArray[11], $messageByteArray[12] - 2];
+    }
+
+    public function getRuntimeInfo(): string
+    {
+        return RuntimeLogger::getRuntimeInfo();
+    }
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/referencecache/ArrayWrapper.php

@@ -0,0 +1,122 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\referencecache;
+
+use ArrayAccess;
+use Countable;
+use Iterator;
+
+final class ArrayWrapper implements ArrayAccess, Countable, Iterator
+{
+    private array $data;
+    private int $position = 0;
+
+    public function __construct(array $data)
+    {
+        $this->data = $data;
+    }
+
+    public function &getData(): array
+    {
+        return $this->data;
+    }
+
+    public function setData(array $data): void
+    {
+        $this->data = $data;
+    }
+
+    public function offsetExists($offset): bool
+    {
+        return isset($this->data[$offset]);
+    }
+
+    /**
+     * @param mixed $offset
+     * @return mixed|null
+     */
+    public function offsetGet($offset)
+    {
+        return $this->data[$offset] ?? null;
+    }
+
+    /**
+     * @param mixed $offset
+     * @param mixed $value
+     */
+    public function offsetSet($offset, $value): void
+    {
+        if (is_null($offset)) {
+            $this->data[] = $value;
+        } else {
+            $this->data[$offset] = $value;
+        }
+    }
+
+    /**
+     * @param $offset
+     */
+    public function offsetUnset($offset): void
+    {
+        unset($this->data[$offset]);
+    }
+
+    public function count(): int
+    {
+        return count($this->data);
+    }
+
+    /**
+     * @return false|mixed
+     */
+    public function current()
+    {
+        return current($this->data);
+    }
+
+    /**
+     * @return int|string|null
+     */
+    public function key()
+    {
+        return key($this->data);
+    }
+
+    public function next(): void
+    {
+        next($this->data);
+    }
+
+    public function rewind(): void
+    {
+        reset($this->data);
+        $this->position = 0;
+    }
+
+    public function valid(): bool
+    {
+        return key($this->data) !== null;
+    }
+
+    public function getRank(): int
+    {
+        if (empty($this->data)) {
+            return 1;
+        }
+
+        $maxRank = 0;
+        foreach ($this->data as $element) {
+            if (is_array($element)) {
+                $elementWrapper = new ArrayWrapper($element);
+                $rank = $elementWrapper->getRank();
+                if ($rank > $maxRank) {
+                    $maxRank = $rank;
+                }
+            }
+        }
+
+        return 1 + $maxRank;
+    }
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/referencecache/ReferencesCache.php

@@ -0,0 +1,68 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\referencecache;
+
+use utils\exception\SingletonUnserializeException;
+use utils\Uuid;
+
+final class ReferencesCache
+{
+    private static ?ReferencesCache $instance = null;
+    private array $references = [];
+
+    private function __construct()
+    {
+    }
+
+    public static function getInstance(): ReferencesCache
+    {
+        if (self::$instance === null) {
+            self::$instance = new self();
+        }
+
+        return self::$instance;
+    }
+
+    /**
+     * @param mixed $reference
+     */
+    public function cacheReference($reference): string
+    {
+        $uuid = Uuid::uuid4()->toString();
+        $this->references[$uuid] = $reference;
+
+        return $uuid;
+    }
+
+    /**
+     * @return null|mixed
+     */
+    public function resolveReference(string $uuid)
+    {
+        return $this->references[$uuid] ?? null;
+    }
+
+    public function deleteReference(string $uuid): bool
+    {
+        if (isset($this->references[$uuid])) {
+            unset($this->references[$uuid]);
+            return true;
+        }
+
+        return false;
+    }
+
+    private function __clone()
+    {
+    }
+
+    /**
+     * @throws \Exception
+     */
+    public function __wakeup()
+    {
+        throw new SingletonUnserializeException();
+    }
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/transmitter/Transmitter.php

@@ -0,0 +1,47 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\transmitter;
+
+use RuntimeException;
+use Throwable;
+
+final class Transmitter
+{
+    public static function sendCommand(array $messageByteArray): array
+    {
+        try {
+            return TransmitterWrapper::sendCommand($messageByteArray);
+        } catch (Throwable $e) {
+            throw new RuntimeException('Error sending command: ' . $e->getMessage(), 0, $e);
+        }
+    }
+
+    public static function activate(string $licenseKey): int
+    {
+        try {
+            return TransmitterWrapper::activate($licenseKey);
+        } catch (Throwable $e) {
+            throw new RuntimeException('Error during activation: ' . $e->getMessage(), 0, $e);
+        }
+    }
+
+    public static function setConfigSource(string $configSource): int
+    {
+        try {
+            return TransmitterWrapper::setConfigSource($configSource);
+        } catch (Throwable $e) {
+            throw new RuntimeException('Error setting config source: ' . $e->getMessage(), 0, $e);
+        }
+    }
+
+    public static function setJavonetWorkingDirectory(string $path): int
+    {
+        try {
+            return TransmitterWrapper::setJavonetWorkingDirectory($path);
+        } catch (Throwable $e) {
+            throw new RuntimeException('Error setting working directory: ' . $e->getMessage(), 0, $e);
+        }
+    }
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/transmitter/TransmitterWrapper.php

@@ -0,0 +1,180 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\transmitter;
+
+use FFI;
+use FFI\Exception as FFIException;
+use RuntimeException;
+
+final class TransmitterWrapper
+{
+    private function __construct()
+    {
+    }
+
+    private static ?FFI $phpLib = null;
+
+    private static ?string $workingDirectory = null;
+
+
+    public static function setWorkingDirectoryPath(string $path): void
+    {
+        self::$workingDirectory = $path;
+    }
+    private static function loadNativeLibrary(): void
+    {
+        if (null !== self::$phpLib) {
+            return;
+        }
+
+        $nativeLibPath = self::getNativeLibPath();
+        if (!file_exists($nativeLibPath)) {
+            throw new RuntimeException('Native library not found in path: ' . $nativeLibPath);
+        }
+
+        try {
+            $lib = FFI::cdef(
+            'int Activate(const char* licenseKey);
+                int SendCommand(unsigned char* messageByteArray, int messageByteArrayLen);
+                int ReadResponse(unsigned char* responseByteArray, int responseByteArrayLen);
+                int SetConfigSource(const char* sourcePath);
+                int SetWorkingDirectory(const char* path);
+                const char* GetNativeError();',
+            $nativeLibPath
+            );
+        } catch (FFIException $e) {
+            throw new RuntimeException('Unable to load native library: ' . $e->getMessage());
+        }
+
+        self::$phpLib = $lib;
+    }
+
+    private static function getNativeLibPath(): string
+    {
+        $archSuffix = self::detectArchitecture();
+        $basePath = self::getWorkingDirectoryBasePath();
+        $osName = strtolower(PHP_OS);
+
+        if (strpos($osName, 'win') !== false) {
+            return $basePath . '/Binaries/Native/Windows/' . $archSuffix . '/JavonetPhpRuntimeNative.dll';
+        }
+
+        if (strpos($osName, 'darwin') !== false) {
+            return $basePath . '/Binaries/Native/MacOs/' . $archSuffix . '/libJavonetPhpRuntimeNative.dylib';
+        }
+
+        if (strpos($osName, 'linux') !== false) {
+            return $basePath . '/Binaries/Native/Linux/' . $archSuffix . '/libJavonetPhpRuntimeNative.so';
+        }
+
+        throw new RuntimeException('Unsupported OS: ' . $osName);
+    }
+
+    private static function getWorkingDirectoryBasePath(): string
+    {
+        if (empty(self::$workingDirectory)) {
+            return rtrim(dirname(__DIR__, 3), '/\\\\');
+        }
+
+        return rtrim(self::$workingDirectory, '/\\\\');
+    }
+
+    private static function detectArchitecture(): string
+    {
+        $arch = strtolower(php_uname('m'));
+        if (strpos($arch, 'arm') !== false || strpos($arch, 'aarch') !== false) {
+            return strpos($arch, '64') !== false ? 'ARM64' : 'ARM';
+        }
+
+        if (strpos($arch, '64') !== false) {
+            return 'X64';
+        }
+
+        return 'X86';
+    }
+
+    public static function sendCommand(array $messageByteArray): array
+    {
+        self::loadNativeLibrary();
+
+        $messageLength = count($messageByteArray);
+        $messageBuffer = self::$phpLib->new("unsigned char [$messageLength]");
+        for ($i = 0; $i < $messageLength; $i++) {
+            $messageBuffer[$i] = (int) $messageByteArray[$i] & 0xFF;
+        }
+
+        $responseArrayLen = self::$phpLib->SendCommand($messageBuffer, $messageLength);
+        if ($responseArrayLen > 0) {
+            $responseBuffer = self::$phpLib->new("unsigned char[$responseArrayLen]");
+            self::$phpLib->ReadResponse($responseBuffer, $responseArrayLen);
+
+            $response = [];
+            for ($i = 0; $i < $responseArrayLen; $i++) {
+                $response[] = $responseBuffer[$i];
+            }
+
+            return $response;
+        }
+
+        if ($responseArrayLen === 0) {
+            throw new RuntimeException('Response is empty');
+        }
+
+        throw new RuntimeException('Javonet native error code: ' . $responseArrayLen . self::getErrorMessage());
+    }
+
+    public static function activate(string $licenseKey): int
+    {
+        self::loadNativeLibrary();
+
+        $activationResult = self::$phpLib->Activate($licenseKey);
+        if ($activationResult < 0) {
+            throw new RuntimeException(
+                'Javonet activation result: ' . $activationResult .
+                '. Native error message: ' . self::getErrorMessage()
+            );
+        }
+        return $activationResult;
+    }
+
+    public static function setConfigSource(string $configSource): int
+    {
+        self::loadNativeLibrary();
+
+        $result = self::$phpLib->SetConfigSource($configSource);
+        if ($result < 0) {
+            throw new RuntimeException(
+                'Javonet set config source failed. Result code: ' . $result .
+                '. Native error message: ' . self::getErrorMessage()
+            );
+        }
+
+        return $result;
+    }
+
+    public static function setJavonetWorkingDirectory(string $path): int
+    {
+        self::setWorkingDirectoryPath($path);
+        self::loadNativeLibrary();
+
+        $result = self::$phpLib->SetWorkingDirectory($path);
+        if ($result < 0) {
+            throw new RuntimeException('Javonet set working directory failed. Result code: ' . $result . '" Native error message: "' . self::getErrorMessage());
+        }
+
+        return $result;
+    }
+
+    public static function getErrorMessage(): string
+    {
+        try {
+            $errorMessageCData = self::$phpLib->GetNativeError();
+
+            return $errorMessageCData ?: 'Unknown native error';
+        } catch (FFIException $e) {
+            return 'FFI error calling GetNativeError: ' . $e->getMessage();
+        }
+    }
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/typescache/TypesCache.php

@@ -0,0 +1,60 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\typescache;
+
+final class TypesCache
+{
+    private static ?TypesCache $instance = null;
+    private array $typeCache = [];
+
+    private function __construct() {}
+
+    public static function getInstance(): TypesCache
+    {
+        if (self::$instance === null) {
+            self::$instance = new self();
+        }
+        return self::$instance;
+    }
+
+    public function cacheType(string $typeRegex): int
+    {
+        $this->typeCache[] = $typeRegex;
+
+        return 0;
+    }
+
+    public function isTypeCacheEmpty(): bool
+    {
+        return empty($this->typeCache);
+    }
+
+    public function isTypeAllowed(string $typeToCheck): bool
+    {
+        foreach ($this->typeCache as $typePattern) {
+            if ($typePattern === $typeToCheck) {
+                return true;
+            }
+
+            $typeRegex = str_replace(['\\', '*'], ['\\\\', '.*'], $typePattern);
+            $typeRegex = '/^' . $typeRegex . '$/';
+
+            if (preg_match($typeRegex, $typeToCheck)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public function getTypeCache(): array
+    {
+        return $this->typeCache;
+    }
+
+    public function clearCache(): void
+    {
+        $this->typeCache = [];
+    }
+}