javonet-ruby-sdk 2.5.20 → 2.6.0

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/webSocketClient/WebSocketClient.php

@@ -0,0 +1,211 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\webSocketClient;
+
+use RuntimeException;
+use utils\Uri;
+
+final class WebSocketClient
+{
+    private const SECURE_PORT_NUMBER = 443;
+    private const UNSECURE_PORT_NUMBER = 80;
+    private $socket;
+    private URI $uri;
+    private bool $connected = false;
+
+    public function __construct(URI $uri)
+    {
+        $this->uri = $uri;
+        $port = $this->getPort();
+
+        $this->socket = fsockopen($this->getUri(), $port, $errno, $errstr);
+
+        if ($this->socket === false) {
+            throw new RuntimeException(sprintf('Could not connect to %s : %d - %s (%s)', $uri->getHost(), $port, $errstr, $errno));
+        }
+
+        $this->connect();
+    }
+
+    private function connect(): void
+    {
+        $request = sprintf(
+            "GET %s HTTP/1.1\r\n" .
+            "Host: %s\r\n" .
+            "Upgrade: websocket\r\n" .
+            "Connection: Upgrade\r\n" .
+            "Sec-WebSocket-Key: %s\r\n" .
+            "Sec-WebSocket-Version: 13\r\n\r\n",
+            $this->getPath(),
+            $this->getHost(),
+            $this->generateWebSocketKey()
+        );
+
+        fwrite($this->socket, ...unpack('C*',mb_convert_encoding($request, 'UTF-8')));
+        fflush($this->socket);
+
+        $response = fread($this->socket, 1024);
+        if ($response === false) {
+            fclose($this->socket);
+            throw new RuntimeException('Response read error');
+        }
+
+        if (strpos($response, '101 Switching Protocols') === false) {
+            fclose($this->socket);
+            throw new RuntimeException('Failed to upgrade to WebSocket');
+        }
+
+        $this->connected = true;
+    }
+
+    private function getPath(): string
+    {
+        return $this->uri->isEmptyPath() ? '/' : $this->uri->getPath();
+    }
+
+    private function isSecureConnect(): bool
+    {
+        return strtolower($this->uri->getScheme()) === 'wss';
+    }
+
+    private function getPort(): int
+    {
+        return $this->uri->getPort() ?? $this->isSecureConnect() ? self::SECURE_PORT_NUMBER : self::UNSECURE_PORT_NUMBER;
+    }
+
+    private function getProtocol(): string
+    {
+        return $this->isSecureConnect() ? 'ssl' : 'tcp';
+    }
+
+    private function getHost(): string
+    {
+        $host = $this->uri->getHost();
+        if ($this->uri->isNotEmptyPort()) {
+            return $host . ':' . $this->uri->getPort();
+        }
+
+        return $host;
+    }
+
+    private function getUri(): string
+    {
+        return $this->getProtocol() . '://' . $this->uri->getHost();
+    }
+
+    private function generateWebSocketKey(): string
+    {
+        return base64_encode(random_bytes(16));
+    }
+
+    public static function sendMessage(URI $uri, array $message): array
+    {
+        $client = new WebSocketClient($uri);
+        try {
+            if (!$client->connected) {
+                throw new RuntimeException('WebSocket is not connected');
+            }
+            $client->sendByteArray($message);
+
+            return $client->receiveByteArray();
+        } finally {
+            $client->close();
+        }
+    }
+
+    private function sendByteArray(array $message): void
+    {
+        $length = count($message);
+        $mask = [];
+        for ($i = 0; $i < 4; $i++) {
+            $mask[] = rand(0, 255);
+        }
+
+        $frame[0] = 0x82;
+        $frame[1] = 0x80 | $length;
+
+        for ($i = 0; $i < 4; $i++) {
+            $frame[2 + $i] = $mask[$i];
+        }
+
+        for ($i = 0; $i < $length; $i++) {
+            $frame[6 + $i] = $message[$i] ^ $mask[$i % 4];
+        }
+
+        fwrite($this->socket, ...$frame);
+        fflush($this->socket);
+    }
+
+    private function receiveByteArray(): array
+    {
+        $header = fread($this->socket, 2);
+        if (strlen($header) !== 2) {
+            throw new \RuntimeException('Failed to read WebSocket frame header');
+        }
+
+        $headerBytes = unpack('C*', $header);
+        $isMasked = ($headerBytes[1] & 0x80) !== 0;
+        $payloadLength = $headerBytes[1] & 0x7F;
+
+        if ($payloadLength === 126) {
+            $extendedPayloadLength = fread($this->socket, 2);
+            if (strlen($extendedPayloadLength) !== 2) {
+                throw new \RuntimeException('Failed to read extended payload length');
+            }
+            $extendedPayloadLengthBytes = unpack('C*', $extendedPayloadLength);
+            $payloadLength = (($extendedPayloadLengthBytes[0] & 0xFF) << 8) | ($extendedPayloadLengthBytes[1] & 0xFF);
+        } elseif ($payloadLength === 127) {
+            $extendedPayloadLength = fread($this->socket, 8);
+            if (strlen($extendedPayloadLength) !== 8) {
+                throw new \RuntimeException('Failed to read extended payload length');
+            }
+            $extendedPayloadLengthBytes = unpack('C*', $extendedPayloadLength);
+            $payloadLength = 0;
+            for ($i = 0; $i < 8; $i++) {
+                $payloadLength = ($payloadLength << 8) | ($extendedPayloadLengthBytes[$i] & 0xFF);
+            }
+        }
+
+        $mask = [];
+        if ($isMasked) {
+            $maskBytes = fread($this->socket, 4);
+            if (strlen($maskBytes) !== 4) {
+                throw new \RuntimeException('Failed to read mask');
+            }
+            $mask = unpack('C*', $maskBytes);
+        }
+
+        $payloadBytes = fread($this->socket, $payloadLength);
+        if (strlen($payloadBytes) !== $payloadLength) {
+            throw new \RuntimeException('Failed to read payload');
+        }
+
+        $payload = unpack('C*', $payloadBytes);
+        if ($isMasked) {
+            for ($i = 0; $i < $payloadLength; $i++) {
+                $payload[$i] ^= $mask[$i % 4];
+            }
+        }
+
+        return $payload;
+    }
+
+    public function __destruct()
+    {
+        $this->close();
+    }
+
+    public function close(): void
+    {
+        if ($this->socket) {
+            fwrite($this->socket, "\x88\x00");
+            fflush($this->socket);
+
+            $this->connected = false;
+        }
+
+        fclose($this->socket);
+    }
+}

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

@@ -0,0 +1,176 @@
+<?php
+
+declare(strict_types=1);
+
+namespace utils;
+
+use Exception;
+use utils\type\CommandType;
+
+final class Command implements CommandInterface
+{
+    private RuntimeName $runtimeName;
+    private CommandType $commandType;
+    private array $payload;
+
+    public function __construct(
+        RuntimeName $runtimeName,
+        CommandType $commandType,
+        ...$payload
+    ) {
+        $this->runtimeName = $runtimeName;
+        $this->commandType = $commandType;
+        $this->payload = count($payload) === 1 && is_array($payload[0])
+            ? $payload[0]
+            : $payload;
+    }
+
+    /**
+     * @param mixed $arg
+     */
+    public function addArgToPayload($arg): CommandInterface
+    {
+        return new Command($this->runtimeName, $this->commandType, array_merge($this->payload, [$arg]));
+    }
+
+    /**
+     * @param mixed $value
+     */
+    public function setPayload(int $index, $value): void
+    {
+        $this->payload[$index] = $value;
+    }
+
+    public function getRuntimeName(): RuntimeName
+    {
+        return $this->runtimeName;
+    }
+
+    public function getCommandType(): CommandType
+    {
+        return $this->commandType;
+    }
+
+    public function getPayload(): array
+    {
+        return $this->payload;
+    }
+
+    /**
+     * @return mixed
+     */
+    public function getPayloadByIndex(int $index)
+    {
+        return $this->payload[$index];
+    }
+
+    public function getPayloadSize(): int
+    {
+        return count($this->payload);
+    }
+
+    public function toString(): string
+    {
+        return 'Target runtime: ' . $this->runtimeName->getName() .
+            ' Command type: ' . $this->commandType->getName() .
+            ' Payload: ' . json_encode($this->payload);
+    }
+
+    public function __toString(): string
+    {
+        try {
+            $result = 'RuntimeName: ';
+            $result .= $this->runtimeName->getName();
+            $result .= ' CommandType: ';
+            $result .= $this->commandType->getName();
+            $result .= ' Payload: ';
+            foreach ($this->payload as $value) {
+                $result .= $this->getPayloadValue($value);
+            }
+
+            return $result;
+        } catch (Exception $e) {
+            return 'Error while converting command to string: ' . $e->getMessage();
+        }
+    }
+
+    private function getPayloadValue($value): string
+    {
+        if (null === $value) {
+            return 'null ';
+        }
+
+        return $value . PHP_EOL;
+    }
+
+    /**
+     * @param mixed $response
+     */
+    public static function createResponse($response, RuntimeName $runtimeName): CommandInterface
+    {
+        return new Command($runtimeName, CommandType::VALUE(), $response);
+    }
+
+    public static function createReference(string $uuid, RuntimeName $runtimeName): CommandInterface
+    {
+        return new Command($runtimeName, CommandType::REFERENCE(), $uuid);
+    }
+
+    public static function createArrayResponse(array $array, RuntimeName $runtimeName): CommandInterface
+    {
+        return new Command($runtimeName, CommandType::ARRAY(), $array);
+    }
+
+    public function prependArgumentToPayload(?CommandInterface $currentCommand): CommandInterface
+    {
+        if ($currentCommand === null) {
+            return new self($this->runtimeName, $this->commandType, $this->payload);
+        }
+
+        return new self($this->runtimeName, $this->commandType, [$currentCommand, ...$this->payload]);
+    }
+
+    /**
+     * @param mixed $element
+     */
+    public function equals($element): bool
+    {
+        if ($this === $element) {
+            return true;
+        }
+
+        if (!$element instanceof CommandInterface) {
+            return false;
+        }
+
+        if ($this->runtimeName !== $element->runtimeName || $this->commandType !== $element->commandType) {
+            return false;
+        }
+
+        if (count($this->payload) !== count($element->payload)) {
+            return false;
+        }
+
+        foreach ($this->payload as $index => $payloadItem) {
+            $elementPayloadItem = $element->payload[$index];
+
+            if ($payloadItem instanceof CommandInterface && $elementPayloadItem instanceof CommandInterface) {
+                if (!$payloadItem->equals($elementPayloadItem)) {
+                    return false;
+                }
+            }
+
+            if (is_object($payloadItem) && method_exists($payloadItem, 'equals') && is_object($elementPayloadItem)) {
+                if (!$payloadItem->equals($elementPayloadItem)) {
+                    return false;
+                }
+            }
+
+            elseif ($payloadItem !== $elementPayloadItem) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}

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

@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace utils;
+
+use utils\type\CommandType;
+
+interface CommandInterface
+{
+    public function addArgToPayload($arg): CommandInterface;
+    public function setPayload(int $index, $value): void;
+    public function getRuntimeName(): RuntimeName;
+    public function getCommandType(): CommandType;
+    public function getPayload(): array;
+    public function getPayloadByIndex(int $index);
+    public function getPayloadSize(): int;
+    public function toString(): string;
+    public function __toString(): string;
+    public static function createResponse($response, RuntimeName $runtimeName): CommandInterface;
+    public static function createReference(string $uuid, RuntimeName $runtimeName): CommandInterface;
+    public static function createArrayResponse(array $array, RuntimeName $runtimeName): CommandInterface;
+    public function prependArgumentToPayload(?CommandInterface $currentCommand): CommandInterface;
+    public function equals($element): bool;
+}

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

@@ -0,0 +1,94 @@
+<?php
+
+declare(strict_types=1);
+
+namespace utils;
+
+use utils\type\CommandType;
+use core\interpreter\Interpreter;
+use utils\connectiondata\InMemoryConnectionData;
+use ReflectionClass;
+
+final class DynamicMethodFactory
+{
+    public static function createDynamicClass(
+        string $className,
+        string $returnType,
+        array $paramTypes,
+        RuntimeName $callingRuntimeName,
+        string $delegateGuid
+    ): object {
+        $dynamicClass = new class($returnType, $paramTypes, $callingRuntimeName, $delegateGuid) {
+            private $returnType;
+            private $paramTypes;
+            private $callingRuntimeName;
+            private $delegateGuid;
+            
+            public function __construct($returnType, $paramTypes, $callingRuntimeName, $delegateGuid) {
+                $this->returnType = $returnType;
+                $this->paramTypes = $paramTypes;
+                $this->callingRuntimeName = $callingRuntimeName;
+                $this->delegateGuid = $delegateGuid;
+            }
+            
+            public function methodToExecute(...$args) {
+                $objArgs = [];
+                foreach ($args as $arg) {
+                    $objArgs[] = $arg;
+                }
+
+                $payload = array_merge([$this->delegateGuid], $objArgs);
+
+                $invokeDelegateCommand = new Command(
+                    $this->callingRuntimeName,
+                    CommandType::INVOKE_DELEGATE(),
+                    $payload
+                );
+
+                $interpreter = new Interpreter();
+                $executeCall = $interpreter->execute(
+                    $invokeDelegateCommand, 
+                    new InMemoryConnectionData()
+                );
+
+                $response = $executeCall->getPayload()[0];
+
+                return self::castToType($response, $this->returnType);
+            }
+            
+            private static function castToType($value, string $targetType) {
+                switch ($targetType) {
+                    case 'int':
+                    case 'integer':
+                        return (int) $value;
+                    case 'float':
+                    case 'double':
+                        return (float) $value;
+                    case 'string':
+                        return (string) $value;
+                    case 'bool':
+                    case 'boolean':
+                        return (bool) $value;
+                    case 'array':
+                        return (array) $value;
+                    case 'object':
+                        return (object) $value;
+                    default:
+                        if (class_exists($targetType)) {
+                            if ($value instanceof $targetType) {
+                                return $value;
+                            }
+
+                            $reflection = new ReflectionClass($targetType);
+                            if ($reflection->isInstantiable()) {
+                                return $reflection->newInstance($value);
+                            }
+                        }
+                        return $value;
+                }
+            }
+        };
+        
+        return $dynamicClass;
+    }
+}

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

@@ -0,0 +1,87 @@
+<?php
+
+declare(strict_types=1);
+
+namespace utils;
+
+use utils\exception\enum\{
+    EnumNameNotFoundException,
+    InvalidEnumValueException
+};
+use ReflectionClass;
+use utils\exception\BadMethodCallException;
+
+abstract class Enum
+{
+    private int $value;
+    private static array $instances = [];
+
+    public function __construct(int $value)
+    {
+        $constants = (new ReflectionClass(static::class))->getConstants();
+        if (!in_array($value, $constants, true)) {
+            throw new InvalidEnumValueException(static::class, $value);
+        }
+
+        $this->value = $value;
+    }
+
+    public function getValue(): int
+    {
+        return $this->value;
+    }
+
+    public function getName(): string
+    {
+        foreach ((new ReflectionClass(static::class))->getConstants() as $name => $val) {
+            if ($val === $this->value) {
+                return $name;
+            }
+        }
+
+        throw new EnumNameNotFoundException((string)$this->value);
+    }
+
+    public static function __callStatic(string $method, array $arguments)
+    {
+        $className = static::class;
+        if (isset(self::$instances[$className][$method])) {
+            return self::$instances[$className][$method];
+        }
+
+        $constants = (new ReflectionClass($className))->getConstants();
+
+        if (array_key_exists($method, $constants)) {
+            $instance = new static($constants[$method]);
+            self::$instances[$className][$method] = $instance;
+            return $instance;
+        }
+
+        throw new BadMethodCallException($className, $method);
+    }
+
+    public static function from(int $value): self
+    {
+        $constants = (new ReflectionClass(static::class))->getConstants();
+        if (!in_array($value, $constants, true)) {
+            throw new InvalidEnumValueException(static::class, $value);
+        }
+
+        return new static($value);
+    }
+
+    public function equalsByValue(int $value): bool
+    {
+        return $this->value === $value;
+    }
+
+    public function notEqualsByValue(int $value): bool
+    {
+        return $this->value !== $value;
+    }
+
+    public function __toString(): string
+    {
+        return (string)$this->value;
+    }
+}

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

@@ -0,0 +1,69 @@
+<?php
+
+declare(strict_types=1);
+
+namespace utils;
+
+use Throwable;
+use utils\type\CommandType;
+use utils\type\ExceptionType;
+
+final class ExceptionSerializer
+{
+    public static function serializeException(Throwable $exception, CommandInterface $command): CommandInterface
+    {
+        $exceptionCommand = new Command($command->getRuntimeName(), CommandType::EXCEPTION(), []);
+        $isDebug = false;
+
+        $stackClasses = $stackMethods = $stackLines = $stackFiles = '';
+
+        $trace = $exception->getTrace();
+        if (!$isDebug) {
+            $trace = self::getStackTraceAfterReflection($trace);
+        }
+
+        self::serializeStackTrace($trace, $stackClasses, $stackMethods, $stackLines, $stackFiles);
+
+        $exceptionName = basename(str_replace('\\', '/', get_class($exception)));
+
+        $exceptionCommand = $exceptionCommand->addArgToPayload(ExceptionType::getExceptionCodeByExceptionName($exceptionName));
+        $exceptionCommand = $exceptionCommand->addArgToPayload($command);
+        $exceptionCommand = $exceptionCommand->addArgToPayload($exceptionName);
+        $exceptionCommand = $exceptionCommand->addArgToPayload($exception->getMessage());
+        $exceptionCommand = $exceptionCommand->addArgToPayload($stackClasses);
+        $exceptionCommand = $exceptionCommand->addArgToPayload($stackMethods);
+        $exceptionCommand = $exceptionCommand->addArgToPayload($stackLines);
+        $exceptionCommand = $exceptionCommand->addArgToPayload($stackFiles);
+
+        return $exceptionCommand;
+    }
+
+    private static function serializeStackTrace(
+        array $trace,
+        string &$stackClasses,
+        string &$stackMethods,
+        string &$stackLines,
+        string &$stackFiles
+    ): void {
+        foreach ($trace as $frame) {
+            $stackClasses .= $frame['class'] ?? 'undefined' . '|';
+            $stackMethods .= $frame['function'] ?? 'undefined' . '|';
+            $stackLines .= $frame['line'] ?? '0' . '|';
+            $stackFiles .= $frame['file'] ?? 'undefined' . '|';
+        }
+    }
+
+    private static function getStackTraceAfterReflection(array $trace): array
+    {
+        $index = 0;
+        foreach ($trace as $frame) {
+            $class = $frame['class'] ?? '';
+            if (strpos($class, 'javonet') !== false || strpos($class, 'Reflector') !== false) {
+                break;
+            }
+            $index++;
+        }
+
+        return array_slice($trace, 0, $index);
+    }
+}

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

@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace utils;
+
+use Exception;
+
+final class RuntimeLogger {
+    private static bool $notLoggedYet = true;
+
+    public static function getRuntimeInfo(): string
+    {
+        try {
+            return sprintf(
+                "PHP Managed Runtime Info:\n" .
+                "PHP Version: %s\n" .
+                "PHP executable path: %s\n" .
+                "PHP Path: %s\n" .
+                "PHP Implementation: %s\n" .
+                "OS Version: %s %s\n" .
+                "Process Architecture: %s\n" .
+                "Current Working Directory: %s\n",
+                PHP_VERSION,
+                PHP_BINARY,
+                get_include_path(),
+                PHP_SAPI,
+                PHP_OS_FAMILY,
+                php_uname('r'),
+                php_uname('m'),
+                getcwd()
+            );
+        } catch (Exception $e) {
+            return 'PHP Managed Runtime Info: Error while fetching runtime info';
+        }
+    }
+
+    public static function displayRuntimeInfo(): void
+    {
+        if (self::$notLoggedYet) {
+            echo self::getRuntimeInfo();
+            self::$notLoggedYet = false;
+        }
+    }
+}