javonet-ruby-sdk 2.5.20 → 2.6.0

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

@@ -0,0 +1,54 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use Exception;
+use utils\CommandInterface;
+use utils\exception\JavonetArgumentsMismatchException;
+
+final class InvokeGlobalFunctionHandler extends AbstractHandler
+{
+    private const REQUIRED_ARGUMENTS_COUNT = 1;
+
+    /**
+     * @return mixed
+     */
+    public function process(CommandInterface $command)
+    {
+        if ($command->getPayloadSize() < self::REQUIRED_ARGUMENTS_COUNT) {
+            throw new JavonetArgumentsMismatchException(
+                self::class,
+                self::REQUIRED_ARGUMENTS_COUNT
+            );
+        }
+
+        $functionName = $command->getPayload()[0];
+        $args = array_slice($command->getPayload(), 1);
+
+        if (function_exists($functionName)) {
+            return call_user_func_array($functionName, $args);
+        }
+
+        if (strpos($functionName, '\\') !== false) {
+            if (function_exists($functionName)) {
+                return call_user_func_array($functionName, $args);
+            }
+        }
+
+        if (strpos($functionName, '::') !== false) {
+            [$className, $methodName] = explode('::', $functionName, 2);
+            if (class_exists($className) && method_exists($className, $methodName)) {
+                return call_user_func_array([$className, $methodName], $args);
+            }
+        }
+
+        $availableFunctions = get_defined_functions()['internal'];
+        throw new Exception(sprintf(
+            'Function %s not found. Available built-in internal functions: %s',
+            $functionName,
+            implode(', ', array_slice($availableFunctions, 0, 100)) . '...'
+        ));
+    }
+}

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

@@ -0,0 +1,84 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use BadMethodCallException;
+use core\referencecache\ArrayWrapper;
+use ReflectionClass;
+use ReflectionMethod;
+use ReflectionException;
+use RuntimeException;
+use utils\CommandInterface;
+use utils\exception\JavonetArgumentsMismatchException;
+
+final class InvokeInstanceMethodHandler extends AbstractHandler
+{
+    private const REQUIRED_ARGUMENTS_COUNT = 2;
+
+    /**
+     * @return mixed
+     */
+    public function process(CommandInterface $command)
+    {
+        if ($command->getPayloadSize() < self::REQUIRED_ARGUMENTS_COUNT) {
+            throw new JavonetArgumentsMismatchException(
+                self::class,
+                self::REQUIRED_ARGUMENTS_COUNT
+            );
+        }
+
+        $payload = $command->getPayload();
+        $objectInstance = $payload[0];
+        $methodToInvoke = (string) $payload[1];
+        $arguments = array_slice($payload, 2);
+
+        foreach ($arguments as $i => $arg) {
+            if ($arg instanceof ArrayWrapper) {
+                $arguments[$i] = $arg->getData();
+            }
+        }
+
+        try {
+            $reflectionClass = new ReflectionClass($objectInstance);
+
+            if (!$reflectionClass->hasMethod($methodToInvoke)) {
+                $this->throwMethodNotFoundException($objectInstance, $methodToInvoke, $arguments, $reflectionClass);
+            }
+
+            $method = $reflectionClass->getMethod($methodToInvoke);
+            if ($method->isStatic()) {
+                throw new BadMethodCallException(sprintf('Method %s is static and cannot be called on instance', $methodToInvoke));
+            }
+
+            return $method->invokeArgs($objectInstance, $arguments);
+        } catch (ReflectionException $e) {
+            throw new RuntimeException(sprintf('Cannot access the object: %s, error: %s', get_class($objectInstance), $e->getMessage()));
+        }
+    }
+
+    private function throwMethodNotFoundException($objectInstance, string $methodName, array $arguments, ReflectionClass $reflectionClass): void
+    {
+        $methods = $reflectionClass->getMethods(ReflectionMethod::IS_PUBLIC & ~ReflectionMethod::IS_STATIC);
+        $message = sprintf('Instance method %s with arguments %s was not found in class %s.
+            Available instance methods:' . PHP_EOL, $methodName, json_encode($arguments), get_class($objectInstance)
+        );
+
+        foreach ($methods as $method) {
+            $params = [];
+            foreach ($method->getParameters() as $param) {
+                $paramStr = $param->getType() ? $param->getType()->getName() : 'mixed';
+                $paramStr .= ' $' . $param->getName();
+                if ($param->isOptional()) {
+                    $paramStr .= ' = ' . ($param->isDefaultValueAvailable() ?
+                        var_export($param->getDefaultValue(), true) : 'null');
+                }
+                $params[] = $paramStr;
+            }
+            $message .= $method->getName() . '(' . implode(', ', $params) . ")\n";
+        }
+
+        throw new BadMethodCallException($message);
+    }
+}

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

@@ -0,0 +1,101 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use BadMethodCallException;
+use ReflectionClass;
+use ReflectionMethod;
+use ReflectionException;
+use RuntimeException;
+use utils\CommandInterface;
+use utils\exception\JavonetArgumentsMismatchException;
+
+final class InvokeStaticMethodHandler extends AbstractHandler
+{
+    private const REQUIRED_ARGUMENTS_COUNT = 2;
+
+    public function process(CommandInterface $command)
+    {
+        if ($command->getPayloadSize() < self::REQUIRED_ARGUMENTS_COUNT) {
+            throw new JavonetArgumentsMismatchException(
+                self::class,
+                self::REQUIRED_ARGUMENTS_COUNT
+            );
+        }
+
+        $payload = $command->getPayload();
+        $classToLoad = $payload[0];
+        $methodToInvoke = (string) $payload[1];
+        $arguments = array_slice($payload, 2);
+
+        try {
+            $reflectionClass = $this->getReflectionClass($classToLoad);
+            if (!$reflectionClass->hasMethod($methodToInvoke)) {
+                $this->throwMethodNotFoundException($reflectionClass->getName(), $methodToInvoke, $arguments, $reflectionClass);
+            }
+
+            $method = $reflectionClass->getMethod($methodToInvoke);
+            if (!$method->isStatic()) {
+                throw new BadMethodCallException(sprintf('Method %s is not static', $methodToInvoke));
+            }
+
+            return $method->invokeArgs(null, $arguments);
+        } catch (ReflectionException $e) {
+            throw new RuntimeException(sprintf(
+                'Cannot load the class: %s, error: %s',
+                $this->getClassName($classToLoad),
+                $e->getMessage())
+            );
+        }
+    }
+
+    /**
+     * @param mixed $classToLoad
+     */
+    private function getClassName($classToLoad): string
+    {
+        if ($classToLoad instanceof ReflectionClass) {
+            return $classToLoad->getName();
+        }
+
+        return is_object($classToLoad) ? get_class($classToLoad) : (string) $classToLoad;
+    }
+
+    /**
+     * @param mixed $classToLoad
+     */
+    private function getReflectionClass($classToLoad): ReflectionClass
+    {
+        if ($classToLoad instanceof ReflectionClass) {
+            return $classToLoad;
+        }
+
+        return new ReflectionClass($classToLoad);
+    }
+
+    private function throwMethodNotFoundException(string $className, string $methodName, array $arguments, ReflectionClass $reflectionClass): void
+    {
+        $methods = $reflectionClass->getMethods(ReflectionMethod::IS_STATIC);
+        $message = sprintf('Static method %s with arguments %s was not found in class %s.
+            Available static methods:' . PHP_EOL, $methodName, json_encode($arguments), $className
+        );
+
+        foreach ($methods as $method) {
+            $params = [];
+            foreach ($method->getParameters() as $param) {
+                $paramStr = $param->getType() ? $param->getType()->getName() : 'mixed';
+                $paramStr .= ' $' . $param->getName();
+                if ($param->isOptional()) {
+                    $paramStr .= ' = ' . ($param->isDefaultValueAvailable() ?
+                        var_export($param->getDefaultValue(), true) : 'null');
+                }
+                $params[] = $paramStr;
+            }
+            $message .= $method->getName() . '(' . implode(', ', $params) . ")\n";
+        }
+
+        throw new BadMethodCallException($message);
+    }
+}

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

@@ -0,0 +1,181 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use Exception;
+use ParseError;
+use Phar;
+use RecursiveDirectoryIterator;
+use RecursiveIteratorIterator;
+use utils\CommandInterface;
+use utils\exception\JavonetArgumentsMismatchException;
+
+final class LoadLibraryHandler extends AbstractHandler
+{
+    private const REQUIRED_ARGUMENTS_COUNT = 1;
+    private static array $loadedLibraries = [];
+    private array $loadedClassPaths = [];
+
+    public function process(CommandInterface $command): int
+    {
+        return $this->loadLibrary($command);
+    }
+
+    private function loadLibrary(CommandInterface $command): int
+    {
+        if ($command->getPayloadSize() < self::REQUIRED_ARGUMENTS_COUNT) {
+            throw new JavonetArgumentsMismatchException(
+            self::class,
+                self::REQUIRED_ARGUMENTS_COUNT
+            );
+        }
+
+        $assemblyName = (string) $command->getPayload()[0];
+        if (!file_exists($assemblyName)) {
+            throw new Exception('File not found: ' . $assemblyName);
+        }
+
+        if (in_array($assemblyName, self::$loadedLibraries, true)) {
+            return 0;
+        }
+
+        if (is_dir($assemblyName)) {
+            $this->loadDirectory($assemblyName);
+        } elseif (pathinfo($assemblyName, PATHINFO_EXTENSION) === 'phar') {
+            $this->loadPharFile($assemblyName);
+        } else {
+            $this->loadPhpFile($assemblyName);
+        }
+
+        self::$loadedLibraries[] = $assemblyName;
+        return 0;
+    }
+
+    private function loadDirectory(string $directoryPath): void
+    {
+        if (!is_readable($directoryPath)) {
+            throw new Exception('Directory is not readable: ' . $directoryPath);
+        }
+
+        $realPath = realpath($directoryPath);
+        if ($realPath === false) {
+            throw new Exception('Cannot resolve directory path: ' . $directoryPath);
+        }
+
+        $currentIncludePath = get_include_path();
+        if (strpos($currentIncludePath, $realPath) === false) {
+            set_include_path($currentIncludePath . PATH_SEPARATOR . $realPath);
+            $this->loadedClassPaths[] = $realPath;
+        }
+
+        $this->autoloadPhpFilesFromDirectory($realPath);
+    }
+
+    private function loadPharFile(string $pharPath): void
+    {
+        if (!is_readable($pharPath)) {
+            throw new Exception('PHAR file is not readable: ' . $pharPath);
+        }
+
+        try {
+            $phar = new Phar($pharPath);
+
+            $currentIncludePath = get_include_path();
+            if (strpos($currentIncludePath, $pharPath) === false) {
+                set_include_path($currentIncludePath . PATH_SEPARATOR . $pharPath);
+                $this->loadedClassPaths[] = $pharPath;
+            }
+
+            if (isset($phar['bootstrap.php'])) {
+                include_once 'phar://' . $pharPath . '/bootstrap.php';
+            }
+        } catch (Exception $e) {
+            throw new Exception(sprintf('Error loading PHAR file %s : %s', $pharPath, $e->getMessage()));
+        }
+    }
+
+    private function loadPhpFile(string $filePath): void
+    {
+        if (!is_readable($filePath)) {
+            throw new Exception('PHP file is not readable: ' . $filePath);
+        }
+
+        $fileExtension = pathinfo($filePath, PATHINFO_EXTENSION);
+        if (!in_array($fileExtension, ['php', 'inc'], true)) {
+            throw new Exception('File is not a valid PHP file: ' . $filePath);
+        }
+
+        $code = file_get_contents($filePath);
+        if ($code === false) {
+            throw new Exception(sprintf('Failed to read php file: %s', $filePath));
+        }
+
+        try {
+            token_get_all($code, TOKEN_PARSE);
+        } catch (ParseError $e) {
+            throw new Exception(sprintf('PHP syntax error in file %s: %s', $filePath, $e->getMessage()));
+        }
+
+        $lastError = error_get_last();
+        if ($lastError && $lastError['type'] === E_PARSE) {
+            throw new Exception(sprintf('PHP syntax error in file %s: %s', $filePath, $lastError['message']));
+        }
+
+        include_once $filePath;
+    }
+
+    private function autoloadPhpFilesFromDirectory(string $directory): void
+    {
+        $iterator = new RecursiveIteratorIterator(
+            new RecursiveDirectoryIterator($directory)
+        );
+
+        foreach ($iterator as $file) {
+            if ($file->isFile() && $file->getExtension() === 'php') {
+                include_once $file->getPathname();
+            }
+        }
+    }
+
+    public static function getLoadedLibraries(): array
+    {
+        return self::$loadedLibraries;
+    }
+
+    public function __destruct()
+    {
+        foreach ($this->loadedClassPaths as $path) {
+            if (strpos($path, sys_get_temp_dir()) === 0 && is_dir($path)) {
+                $this->removeDirectoryOrFile($path);
+            }
+        }
+    }
+
+    private function removeDirectoryOrFile(string $dir): void
+    {
+        if (!file_exists($dir)) {
+            return;
+        }
+
+        if (is_file($dir) || is_link($dir)) {
+            if (!unlink($dir)) {
+                throw new Exception('Cannot delete file path: ' . $dir);
+            }
+
+            return;
+        }
+        $files = scandir($dir);
+        foreach ($files as $file) {
+            if ($file === '.' || $file === '..') {
+                continue;
+            }
+            $this->removeDirectoryOrFile($dir . DIRECTORY_SEPARATOR . $file);
+        }
+
+        if(!rmdir($dir)) {
+            throw new Exception('Cannot delete dir path: '. $dir);
+        }
+    }
+}

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

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use utils\CommandInterface;
+use BadMethodCallException;
+
+final class OptimizeHandler extends AbstractHandler
+{
+    public function process(CommandInterface $command)
+    {
+        throw new BadMethodCallException('Optimize method is not available for PHP');
+    }
+}

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

@@ -0,0 +1,61 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use utils\DynamicMethodFactory;
+use ReflectionMethod;
+use utils\CommandInterface;
+use utils\exception\JavonetArgumentsMismatchException;
+use utils\RuntimeName;
+
+final class PassDelegateHandler extends AbstractHandler
+{
+    private const REQUIRED_ARGUMENTS_COUNT = 1;
+
+    public function process(CommandInterface $command): ReflectionMethod
+    {
+        if ($command->getPayloadSize() < self::REQUIRED_ARGUMENTS_COUNT) {
+            throw new JavonetArgumentsMismatchException(self::class, self::REQUIRED_ARGUMENTS_COUNT);
+        }
+
+        $delegateGuid = (string) $command->getPayload()[0];
+        $callingRuntimeName = (int) $command->getPayload()[1];
+        $delegateArgs = $this->getArguments($command);
+
+        $delegateArgsTypes = $this->getArgumentTypes($delegateArgs);
+        $delegateReturnType = $this->getReturnType($delegateArgs);
+
+        $dynamicClass = DynamicMethodFactory::createDynamicClass(
+            'DynamicallyCreatedDelegate',
+            $delegateReturnType,
+            $delegateArgsTypes,
+            new RuntimeName($callingRuntimeName),
+            $delegateGuid
+        );
+
+        return new ReflectionMethod($dynamicClass, 'methodToExecute');
+    }
+
+    private function getArguments(CommandInterface $command): array
+    {
+        return $command->getPayloadSize() > 2
+            ? array_slice($command->getPayload(), 2)
+            : [];
+    }
+
+    private function getArgumentTypes(array $args): array
+    {
+        $argsTypes = [];
+        for ($i = 0; $i < count($args) - 1; $i++) {
+            $argsTypes[$i] = $args[$i];
+        }
+        return $argsTypes;
+    }
+
+    private function getReturnType(array $args): string
+    {
+        return (string) $args[count($args) - 1];
+    }
+}

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

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use core\referencecache\ReferencesCache;
+
+use utils\CommandInterface;
+use utils\Command;
+use utils\exception\JavonetArgumentsMismatchException;
+use utils\RuntimeName;
+use utils\type\CommandType;
+
+final class ResolveInstanceHandler extends AbstractHandler
+{
+    private const REQUIRED_ARGUMENTS_COUNT = 1;
+
+    public function process(CommandInterface $command)
+    {
+        if (self::REQUIRED_ARGUMENTS_COUNT !== $command->getPayloadSize()) {
+            throw new JavonetArgumentsMismatchException(
+                self::class,
+                self::REQUIRED_ARGUMENTS_COUNT
+            );
+        }
+        if ($command->getRuntimeName()->equalsByValue(RuntimeName::PHP)) {
+            return ReferencesCache::getInstance()->resolveReference($command->getPayload()[0]);
+        }
+
+        return new Command($command->getRuntimeName(), CommandType::REFERENCE(), $command->getPayload()[0]);
+    }
+}

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

@@ -0,0 +1,41 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use ReflectionClass;
+use ReflectionException;
+use utils\CommandInterface;
+use utils\exception\FieldNotFoundInClassException;
+use utils\exception\JavonetArgumentsMismatchException;
+
+final class SetInstanceFieldHandler extends AbstractHandler
+{
+    private const REQUIRED_ARGUMENTS_COUNT = 3;
+
+    public function process(CommandInterface $command): int
+    {
+        if ($command->getPayloadSize() < self::REQUIRED_ARGUMENTS_COUNT) {
+            throw new JavonetArgumentsMismatchException(
+            self::class,
+                self::REQUIRED_ARGUMENTS_COUNT
+            );
+        }
+
+        $objectInstance = $command->getPayloadByIndex(0);
+        $fieldName = (string) $command->getPayloadByIndex(1);
+        $newValue = $command->getPayloadByIndex(2);
+
+        try {
+            $reflectionClass = new ReflectionClass($objectInstance);
+            $property = $reflectionClass->getProperty($fieldName);
+            $property->setAccessible(true);
+            $property->setValue($objectInstance, $newValue);
+        } catch (ReflectionException $e) {
+            throw new FieldNotFoundInClassException($fieldName, $objectInstance);
+        }
+
+        return 0;
+    }
+}

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

@@ -0,0 +1,62 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use ReflectionClass;
+use ReflectionException;
+use Exception;
+use utils\CommandInterface;
+use utils\exception\FieldNotFoundInClassException;
+use utils\exception\JavonetArgumentsMismatchException;
+
+final class SetStaticFieldHandler extends AbstractHandler
+{
+    private const REQUIRED_ARGUMENTS_COUNT = 3;
+
+    public function process(CommandInterface $command): int
+    {
+        if ($command->getPayloadSize() < self::REQUIRED_ARGUMENTS_COUNT) {
+            throw new JavonetArgumentsMismatchException(
+            self::class,
+                self::REQUIRED_ARGUMENTS_COUNT
+            );
+        }
+
+        $classToLoad = $command->getPayloadByIndex(0);
+        $fieldName = (string) $command->getPayloadByIndex(1);
+        $newValue = $command->getPayloadByIndex(2);
+
+        try {
+            $reflectionClass = $this->getReflectionClass($classToLoad);
+            if (!$reflectionClass->hasProperty($fieldName)) {
+                throw new ReflectionException(sprintf('Property %s not found', $fieldName));
+            }
+
+            $property = $reflectionClass->getProperty($fieldName);
+            if (!$property->isStatic()) {
+                throw new Exception(sprintf('Property %s is not static', $fieldName));
+            }
+
+            $property->setAccessible(true);
+            $property->setValue(null, $newValue);
+        } catch (ReflectionException $e) {
+            throw new FieldNotFoundInClassException($fieldName, $classToLoad);
+        }
+
+        return 0;
+    }
+
+    /**
+     * @param mixed $classToLoad
+     */
+    private function getReflectionClass($classToLoad): ReflectionClass
+    {
+        if ($classToLoad instanceof ReflectionClass) {
+            return $classToLoad;
+        }
+
+        return new ReflectionClass($classToLoad);
+    }
+}

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

@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use utils\CommandInterface;
+
+final class ValueHandler extends AbstractHandler
+{
+    /**
+     * @return mixed
+     */
+    public function process(CommandInterface $command)
+    {
+        return $command->getPayload()[0];
+    }
+}