diff options
Diffstat (limited to 'crates/shirabe-php-rpc')
| -rw-r--r-- | crates/shirabe-php-rpc/php/stubs/Composer/Composer.php | 88 | ||||
| -rw-r--r-- | crates/shirabe-php-rpc/php/stubs/Composer/IO/BaseIO.php | 193 | ||||
| -rw-r--r-- | crates/shirabe-php-rpc/php/stubs/Composer/IO/BufferIO.php | 19 | ||||
| -rw-r--r-- | crates/shirabe-php-rpc/php/stubs/Composer/IO/ConsoleIO.php | 27 | ||||
| -rw-r--r-- | crates/shirabe-php-rpc/php/stubs/Composer/IO/NullIO.php | 10 | ||||
| -rw-r--r-- | crates/shirabe-php-rpc/php/stubs/Composer/PartialComposer.php | 113 | ||||
| -rw-r--r-- | crates/shirabe-php-rpc/php/worker.php | 143 | ||||
| -rw-r--r-- | crates/shirabe-php-rpc/src/lib.rs | 86 |
8 files changed, 658 insertions, 21 deletions
diff --git a/crates/shirabe-php-rpc/php/stubs/Composer/Composer.php b/crates/shirabe-php-rpc/php/stubs/Composer/Composer.php new file mode 100644 index 00000000..1bb9f64c --- /dev/null +++ b/crates/shirabe-php-rpc/php/stubs/Composer/Composer.php @@ -0,0 +1,88 @@ +<?php + +// Hand-written proxy stub for Composer\Composer, kept in the shape the future stub generator +// will output. Class constants and static methods are materialized (they read no instance +// state); instance methods forward to the Rust-side entity. + +namespace Composer; + +use Composer\Autoload\AutoloadGenerator; +use Composer\Package\Archiver\ArchiveManager; +use Composer\Package\Locker; +use Composer\Downloader\DownloadManager; +use Composer\Pcre\Preg; +use Composer\Plugin\PluginManager; + +class Composer extends PartialComposer +{ + public const VERSION = '2.9.7'; + public const BRANCH_ALIAS_VERSION = ''; + public const RELEASE_DATE = '2026-04-14 13:31:52'; + public const SOURCE_VERSION = ''; + public const RUNTIME_API_VERSION = '2.2.2'; + + public static function getVersion(): string + { + // no replacement done, this must be a source checkout + if (self::VERSION === '@package_version'.'@') { + return self::SOURCE_VERSION; + } + + // we have a branch alias and version is a commit id, this must be a snapshot build + if (self::BRANCH_ALIAS_VERSION !== '' && Preg::isMatch('{^[a-f0-9]{40}$}', self::VERSION)) { + return self::BRANCH_ALIAS_VERSION.'+'.self::VERSION; + } + + return self::VERSION; + } + + public function setLocker(Locker $locker): void + { + \ShirabeRpcRuntime::callRust($this->__rhandle, 'setLocker', [$locker]); + } + + public function getLocker(): Locker + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getLocker', []); + } + + public function setDownloadManager(DownloadManager $manager): void + { + \ShirabeRpcRuntime::callRust($this->__rhandle, 'setDownloadManager', [$manager]); + } + + public function getDownloadManager(): DownloadManager + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getDownloadManager', []); + } + + public function setArchiveManager(ArchiveManager $manager): void + { + \ShirabeRpcRuntime::callRust($this->__rhandle, 'setArchiveManager', [$manager]); + } + + public function getArchiveManager(): ArchiveManager + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getArchiveManager', []); + } + + public function setPluginManager(PluginManager $manager): void + { + \ShirabeRpcRuntime::callRust($this->__rhandle, 'setPluginManager', [$manager]); + } + + public function getPluginManager(): PluginManager + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getPluginManager', []); + } + + public function setAutoloadGenerator(AutoloadGenerator $autoloadGenerator): void + { + \ShirabeRpcRuntime::callRust($this->__rhandle, 'setAutoloadGenerator', [$autoloadGenerator]); + } + + public function getAutoloadGenerator(): AutoloadGenerator + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getAutoloadGenerator', []); + } +} diff --git a/crates/shirabe-php-rpc/php/stubs/Composer/IO/BaseIO.php b/crates/shirabe-php-rpc/php/stubs/Composer/IO/BaseIO.php new file mode 100644 index 00000000..3a268c22 --- /dev/null +++ b/crates/shirabe-php-rpc/php/stubs/Composer/IO/BaseIO.php @@ -0,0 +1,193 @@ +<?php + +// Hand-written proxy stub for Composer\IO\BaseIO, kept in the shape the future stub generator +// will output: every public method of the real class (its own and the IOInterface / +// LoggerInterface surface) forwards to the Rust-side entity. Loading this stub pulls the real +// IOInterface contract from the Composer PHP runtime, which must already be required. + +namespace Composer\IO; + +use Composer\Config; + +abstract class BaseIO implements IOInterface, \ShirabeRustStub +{ + /** @var int */ + protected $__rhandle; + /** @var int */ + protected $__epoch; + + public function __construct(int $rhandle, int $epoch) + { + $this->__rhandle = $rhandle; + $this->__epoch = $epoch; + } + + public function __destruct() + { + \ShirabeRustObjectRegistry::release($this->__rhandle); + } + + public function __shirabeRustHandleDescriptor(): array + { + return [ + '__rhandle' => $this->__rhandle, + '__class' => static::class, + '__epoch' => $this->__epoch, + ]; + } + + public function isInteractive() + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'isInteractive', []); + } + + public function isVerbose() + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'isVerbose', []); + } + + public function isVeryVerbose() + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'isVeryVerbose', []); + } + + public function isDebug() + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'isDebug', []); + } + + public function isDecorated() + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'isDecorated', []); + } + + public function write($messages, bool $newline = true, int $verbosity = self::NORMAL) + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'write', [$messages, $newline, $verbosity]); + } + + public function writeError($messages, bool $newline = true, int $verbosity = self::NORMAL) + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'writeError', [$messages, $newline, $verbosity]); + } + + public function writeRaw($messages, bool $newline = true, int $verbosity = self::NORMAL) + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'writeRaw', [$messages, $newline, $verbosity]); + } + + public function writeErrorRaw($messages, bool $newline = true, int $verbosity = self::NORMAL) + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'writeErrorRaw', [$messages, $newline, $verbosity]); + } + + public function overwrite($messages, bool $newline = true, ?int $size = null, int $verbosity = self::NORMAL) + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'overwrite', [$messages, $newline, $size, $verbosity]); + } + + public function overwriteError($messages, bool $newline = true, ?int $size = null, int $verbosity = self::NORMAL) + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'overwriteError', [$messages, $newline, $size, $verbosity]); + } + + public function ask(string $question, $default = null) + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'ask', [$question, $default]); + } + + public function askConfirmation(string $question, bool $default = true) + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'askConfirmation', [$question, $default]); + } + + public function askAndValidate(string $question, callable $validator, ?int $attempts = null, $default = null) + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'askAndValidate', [$question, $validator, $attempts, $default]); + } + + public function askAndHideAnswer(string $question) + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'askAndHideAnswer', [$question]); + } + + public function select(string $question, array $choices, $default, $attempts = false, string $errorMessage = 'Value "%s" is invalid', bool $multiselect = false) + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'select', [$question, $choices, $default, $attempts, $errorMessage, $multiselect]); + } + + public function getAuthentications() + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getAuthentications', []); + } + + public function resetAuthentications() + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'resetAuthentications', []); + } + + public function hasAuthentication(string $repositoryName) + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'hasAuthentication', [$repositoryName]); + } + + public function getAuthentication(string $repositoryName) + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getAuthentication', [$repositoryName]); + } + + public function setAuthentication(string $repositoryName, string $username, ?string $password = null) + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'setAuthentication', [$repositoryName, $username, $password]); + } + + public function loadConfiguration(Config $config) + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'loadConfiguration', [$config]); + } + + public function emergency($message, array $context = []): void + { + \ShirabeRpcRuntime::callRust($this->__rhandle, 'emergency', [$message, $context]); + } + + public function alert($message, array $context = []): void + { + \ShirabeRpcRuntime::callRust($this->__rhandle, 'alert', [$message, $context]); + } + + public function critical($message, array $context = []): void + { + \ShirabeRpcRuntime::callRust($this->__rhandle, 'critical', [$message, $context]); + } + + public function error($message, array $context = []): void + { + \ShirabeRpcRuntime::callRust($this->__rhandle, 'error', [$message, $context]); + } + + public function warning($message, array $context = []): void + { + \ShirabeRpcRuntime::callRust($this->__rhandle, 'warning', [$message, $context]); + } + + public function notice($message, array $context = []): void + { + \ShirabeRpcRuntime::callRust($this->__rhandle, 'notice', [$message, $context]); + } + + public function info($message, array $context = []): void + { + \ShirabeRpcRuntime::callRust($this->__rhandle, 'info', [$message, $context]); + } + + public function debug($message, array $context = []): void + { + \ShirabeRpcRuntime::callRust($this->__rhandle, 'debug', [$message, $context]); + } + + public function log($level, $message, array $context = []): void + { + \ShirabeRpcRuntime::callRust($this->__rhandle, 'log', [$level, $message, $context]); + } +} diff --git a/crates/shirabe-php-rpc/php/stubs/Composer/IO/BufferIO.php b/crates/shirabe-php-rpc/php/stubs/Composer/IO/BufferIO.php new file mode 100644 index 00000000..e95fb2da --- /dev/null +++ b/crates/shirabe-php-rpc/php/stubs/Composer/IO/BufferIO.php @@ -0,0 +1,19 @@ +<?php + +// Hand-written proxy stub for Composer\IO\BufferIO, kept in the shape the future stub +// generator will output. + +namespace Composer\IO; + +class BufferIO extends ConsoleIO +{ + public function getOutput(): string + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getOutput', []); + } + + public function setUserInputs(array $inputs): void + { + \ShirabeRpcRuntime::callRust($this->__rhandle, 'setUserInputs', [$inputs]); + } +} diff --git a/crates/shirabe-php-rpc/php/stubs/Composer/IO/ConsoleIO.php b/crates/shirabe-php-rpc/php/stubs/Composer/IO/ConsoleIO.php new file mode 100644 index 00000000..6a4c2ac4 --- /dev/null +++ b/crates/shirabe-php-rpc/php/stubs/Composer/IO/ConsoleIO.php @@ -0,0 +1,27 @@ +<?php + +// Hand-written proxy stub for Composer\IO\ConsoleIO, kept in the shape the future stub +// generator will output. The IOInterface surface is inherited from the BaseIO stub; only the +// public methods ConsoleIO adds are declared here. + +namespace Composer\IO; + +use Symfony\Component\Console\Helper\Table; + +class ConsoleIO extends BaseIO +{ + public function enableDebugging(float $startTime) + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'enableDebugging', [$startTime]); + } + + public function getProgressBar(int $max = 0) + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getProgressBar', [$max]); + } + + public function getTable(): Table + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getTable', []); + } +} diff --git a/crates/shirabe-php-rpc/php/stubs/Composer/IO/NullIO.php b/crates/shirabe-php-rpc/php/stubs/Composer/IO/NullIO.php new file mode 100644 index 00000000..92e01700 --- /dev/null +++ b/crates/shirabe-php-rpc/php/stubs/Composer/IO/NullIO.php @@ -0,0 +1,10 @@ +<?php + +// Hand-written proxy stub for Composer\IO\NullIO, kept in the shape the future stub generator +// will output. The whole surface is inherited from the BaseIO stub. + +namespace Composer\IO; + +class NullIO extends BaseIO +{ +} diff --git a/crates/shirabe-php-rpc/php/stubs/Composer/PartialComposer.php b/crates/shirabe-php-rpc/php/stubs/Composer/PartialComposer.php new file mode 100644 index 00000000..7f085178 --- /dev/null +++ b/crates/shirabe-php-rpc/php/stubs/Composer/PartialComposer.php @@ -0,0 +1,113 @@ +<?php + +// Hand-written proxy stub for Composer\PartialComposer, kept in the shape the future stub +// generator will output: the real public methods, each forwarding to the Rust-side entity. +// Methods the Rust dispatcher does not support yet surface as explicit RPC errors. + +namespace Composer; + +use Composer\Autoload\AutoloadGenerator; +use Composer\Config; +use Composer\EventDispatcher\EventDispatcher; +use Composer\Installer\InstallationManager; +use Composer\Package\RootPackageInterface; +use Composer\Repository\RepositoryManager; +use Composer\Util\Loop; + +class PartialComposer implements \ShirabeRustStub +{ + /** @var int */ + protected $__rhandle; + /** @var int */ + protected $__epoch; + + public function __construct(int $rhandle, int $epoch) + { + $this->__rhandle = $rhandle; + $this->__epoch = $epoch; + } + + public function __destruct() + { + \ShirabeRustObjectRegistry::release($this->__rhandle); + } + + public function __shirabeRustHandleDescriptor(): array + { + return [ + '__rhandle' => $this->__rhandle, + '__class' => static::class, + '__epoch' => $this->__epoch, + ]; + } + + public function setPackage(RootPackageInterface $package): void + { + \ShirabeRpcRuntime::callRust($this->__rhandle, 'setPackage', [$package]); + } + + public function getPackage(): RootPackageInterface + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getPackage', []); + } + + public function setConfig(Config $config): void + { + \ShirabeRpcRuntime::callRust($this->__rhandle, 'setConfig', [$config]); + } + + public function getConfig(): Config + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getConfig', []); + } + + public function setLoop(Loop $loop): void + { + \ShirabeRpcRuntime::callRust($this->__rhandle, 'setLoop', [$loop]); + } + + public function getLoop(): Loop + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getLoop', []); + } + + public function setRepositoryManager(RepositoryManager $manager): void + { + \ShirabeRpcRuntime::callRust($this->__rhandle, 'setRepositoryManager', [$manager]); + } + + public function getRepositoryManager(): RepositoryManager + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getRepositoryManager', []); + } + + public function setInstallationManager(InstallationManager $manager): void + { + \ShirabeRpcRuntime::callRust($this->__rhandle, 'setInstallationManager', [$manager]); + } + + public function getInstallationManager(): InstallationManager + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getInstallationManager', []); + } + + public function setEventDispatcher(EventDispatcher $eventDispatcher): void + { + \ShirabeRpcRuntime::callRust($this->__rhandle, 'setEventDispatcher', [$eventDispatcher]); + } + + public function getEventDispatcher(): EventDispatcher + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getEventDispatcher', []); + } + + public function isGlobal(): bool + { + return \ShirabeRpcRuntime::callRust($this->__rhandle, 'isGlobal', []); + } + + public function setGlobal(): void + { + \ShirabeRpcRuntime::callRust($this->__rhandle, 'setGlobal', []); + } +} diff --git a/crates/shirabe-php-rpc/php/worker.php b/crates/shirabe-php-rpc/php/worker.php index ce11158e..d8f10e93 100644 --- a/crates/shirabe-php-rpc/php/worker.php +++ b/crates/shirabe-php-rpc/php/worker.php @@ -64,11 +64,66 @@ final class ShirabeRustObjectRegistry } } +/** + * The P table: PHP-owned entities exposed to Rust, keyed by phandle. Entries are strong + * references — an entity stays alive until the Rust side sends ReleasePhpHandle. + */ +final class ShirabePhpObjectRegistry +{ + /** @var array<int, object> */ + private static array $objects = []; + /** @var array<int, int> spl_object_id => phandle, so one entity keeps one handle */ + private static array $handlesByObjectId = []; + private static int $nextPhandle = 1; + + public static function register(object $obj): int + { + $objectId = spl_object_id($obj); + $existing = self::$handlesByObjectId[$objectId] ?? null; + if ($existing !== null && isset(self::$objects[$existing])) { + return $existing; + } + $phandle = self::$nextPhandle++; + self::$objects[$phandle] = $obj; + self::$handlesByObjectId[$objectId] = $phandle; + return $phandle; + } + + public static function get(int $phandle): object + { + if (!isset(self::$objects[$phandle])) { + throw new RuntimeException("unknown PHP handle {$phandle}"); + } + return self::$objects[$phandle]; + } + + public static function release(int $phandle): void + { + $obj = self::$objects[$phandle] ?? null; + unset(self::$objects[$phandle]); + if ($obj !== null) { + unset(self::$handlesByObjectId[spl_object_id($obj)]); + } + } + + /** @return array{__phandle: int, __class: string, __implements: list<string>} */ + public static function descriptor(object $obj): array + { + return [ + '__phandle' => self::register($obj), + '__class' => get_class($obj), + '__implements' => array_values(class_implements($obj)), + ]; + } +} + final class ShirabeRpcRuntime { /** @var resource */ public static $socket; public static ?string $stubsDir = null; + /** @var ?callable(string): void */ + public static $stubAutoloader = null; /** @var array<string, callable(array): mixed> */ public static array $dispatch = []; /** Even correlation ids; the Rust side allocates odd ones. */ @@ -147,11 +202,7 @@ final class ShirabeRpcRuntime return $value->__shirabeRustHandleDescriptor(); } if (is_object($value)) { - // TODO(plugin): PHP-owned objects (the P table) are not implemented yet; only Rust - // proxy stubs can cross the boundary until the plugin activation milestone. - throw new RuntimeException( - 'returning a PHP object over RPC is not supported yet: ' . get_class($value) - ); + return ShirabePhpObjectRegistry::descriptor($value); } if (is_resource($value)) { throw new RuntimeException('a PHP resource cannot cross the RPC boundary'); @@ -176,8 +227,7 @@ final class ShirabeRpcRuntime ); } if (isset($value['__phandle'])) { - // TODO(plugin): the P table is not implemented yet. - throw new RuntimeException('__phandle descriptors are not supported yet'); + return ShirabePhpObjectRegistry::get((int) $value['__phandle']); } if (isset($value['__pclass']) && count($value) === 1) { return $value['__pclass']; @@ -261,19 +311,31 @@ final class ShirabeRpcRuntime }); break; case SHIRABE_TAG_NEW_OBJECT: - self::replyWith($corrId, static function () { - // TODO(plugin): requires the P table (plugin activation milestone M2). - throw new RuntimeException('NewObject is not supported yet'); + [$class, $ctorArgs] = $fields; + self::replyWith($corrId, static function () use ($class, $ctorArgs) { + $ctorArgs = ShirabeRpcRuntime::fromWire($ctorArgs); + if (!class_exists($class)) { + throw new RuntimeException("PHP class `{$class}` does not exist"); + } + return new $class(...$ctorArgs); }); break; case SHIRABE_TAG_CALL_PHP_METHOD: - self::replyWith($corrId, static function () { - // TODO(plugin): requires the P table (plugin activation milestone M2). - throw new RuntimeException('CallPhpMethod is not supported yet'); + [$phandle, $method, $args] = $fields; + self::replyWith($corrId, static function () use ($phandle, $method, $args) { + $obj = ShirabePhpObjectRegistry::get((int) $phandle); + $args = ShirabeRpcRuntime::fromWire($args); + if (!is_callable([$obj, $method])) { + throw new RuntimeException( + get_class($obj) . "::{$method} is not callable" + ); + } + return $obj->$method(...$args); }); break; case SHIRABE_TAG_RELEASE_PHP_HANDLE: - // TODO(plugin): the P table is not implemented yet; nothing to release. + [$phandle] = $fields; + ShirabePhpObjectRegistry::release((int) $phandle); break; case SHIRABE_TAG_EPOCH_BUMP: [$rhandle, $epoch] = $fields; @@ -308,6 +370,16 @@ final class ShirabeRpcRuntime * resolved by asking the Rust-side ClassLoader (built by EventDispatcher::makeAutoloader) * where the class file lives. Handle 0 is the runtime service endpoint on the Rust side. */ + /** Re-prepends the stub autoloader so it precedes any autoloader registered since. */ + public static function ensureStubAutoloaderPriority(): void + { + if (self::$stubAutoloader === null) { + return; + } + spl_autoload_unregister(self::$stubAutoloader); + spl_autoload_register(self::$stubAutoloader, true, true); + } + public static function enableScriptAutoloader(): void { if (self::$scriptAutoloaderRegistered) { @@ -332,8 +404,9 @@ ShirabeRpcRuntime::$stubsDir = $argv[2] ?? null; // Proxy stub classes take priority over any other autoloader (including autoloaders that a // script or the composer runtime registers later), so a proxied FQCN can never be shadowed by -// the real implementation. -spl_autoload_register(static function (string $class): void { +// the real implementation. `__shirabe_require` re-prepends this closure after loading code +// that registers its own prepending autoloader. +ShirabeRpcRuntime::$stubAutoloader = static function (string $class): void { if (ShirabeRpcRuntime::$stubsDir === null) { return; } @@ -341,7 +414,8 @@ spl_autoload_register(static function (string $class): void { if (is_file($file)) { require $file; } -}, true, true); +}; +spl_autoload_register(ShirabeRpcRuntime::$stubAutoloader, true, true); // Port of Composer\XdebugHandler\XdebugHandler::setXdebugDetails(), which the diagnose payload // reports as `xdebug_active`. @@ -481,12 +555,47 @@ ShirabeRpcRuntime::$dispatch = [ '__shirabe_oracle_roundtrip' => static fn($args) => serialize(unserialize($args[0], ['allowed_classes' => false])), '__shirabe_require' => static function ($args) { require_once $args[0]; + // The required file may have registered further prepending autoloaders (a Composer + // vendor/autoload.php prepends its ClassLoader); proxied FQCNs must stay resolvable to + // the stub classes, so the stub autoloader is moved back to the front of the stack. + ShirabeRpcRuntime::ensureStubAutoloaderPriority(); return true; }, '__shirabe_enable_script_autoloader' => static function ($args) { ShirabeRpcRuntime::enableScriptAutoloader(); return true; }, + // The body of \Composer\Autoload\composerRequire (AutoloadGenerator.php), sharing its + // $GLOBALS guard so files already required by a real Composer autoloader in this process + // are not required twice. + '__shirabe_composer_require' => static function ($args) { + [$fileIdentifier, $file] = $args; + if (empty($GLOBALS['__composer_autoload_files'][$fileIdentifier])) { + $GLOBALS['__composer_autoload_files'][$fileIdentifier] = true; + + require $file; + } + return true; + }, + // Mirrors FilesystemRepository::write's in-process `InstalledVersions::reload($versions)` + // into this child. The class_exists guard (no autoload) matches the upstream observable + // behavior: when the class was never loaded here, a later lazy load reads the + // freshly-written installed.php anyway. + '__shirabe_installed_versions_reload' => static function ($args) { + if (class_exists('Composer\\InstalledVersions', false)) { + \Composer\InstalledVersions::reload($args[0]); + } + return true; + }, + // For testing only: reads a public property of a P-table entity (PHPUnit asserts like + // `$plugins[0]->version` have no method to call). + '__shirabe_get_property' => static function ($args) { + $obj = ShirabeRpcRuntime::fromWire($args[0]); + if (!is_object($obj)) { + throw new RuntimeException('__shirabe_get_property expects a handle argument'); + } + return $obj->{$args[1]}; + }, ]; ShirabeRpcRuntime::serveForever(); diff --git a/crates/shirabe-php-rpc/src/lib.rs b/crates/shirabe-php-rpc/src/lib.rs index 491af072..cfee5e4c 100644 --- a/crates/shirabe-php-rpc/src/lib.rs +++ b/crates/shirabe-php-rpc/src/lib.rs @@ -11,7 +11,7 @@ use indexmap::IndexMap; use shirabe_external_packages::symfony::process::PhpExecutableFinder; use shirabe_php_shim::PhpMixed; use std::os::unix::net::{UnixListener, UnixStream}; -use std::sync::atomic::{AtomicU64, Ordering}; +use std::sync::atomic::{AtomicBool, AtomicU64, Ordering}; use std::sync::{LazyLock, Mutex, OnceLock}; use std::time::{Duration, Instant}; @@ -396,6 +396,57 @@ pub fn call_static_method( ) } +/// Instantiates `new $class(...$ctor_args)` in the worker (autoloading the class if needed). +/// On success the returned value is a `PluginValue::PhpHandle` registered in the worker's P +/// table; the entity stays alive there until `release_php_handle`. +pub fn new_object( + class: &str, + ctor_args: Vec<PluginValue>, + dispatcher: Option<&mut dyn RustMethodDispatcher>, +) -> anyhow::Result<Result<PluginValue, PhpThrow>> { + rpc_call( + |corr_id| Frame::NewObject { + corr_id, + pclass: class.to_string(), + ctor_args, + }, + dispatcher, + ) +} + +/// Calls `$obj->$method(...$args)` on a P-table entity in the worker. +pub fn call_php_method( + phandle: u64, + method: &str, + args: Vec<PluginValue>, + dispatcher: Option<&mut dyn RustMethodDispatcher>, +) -> anyhow::Result<Result<PluginValue, PhpThrow>> { + rpc_call( + |corr_id| Frame::CallPhpMethod { + corr_id, + phandle, + method_name: method.to_string(), + args, + out_param_positions: Vec::new(), + }, + dispatcher, + ) +} + +/// One-way notification dropping a P-table entity in the worker. Callers releasing from a +/// destructor should ignore the error: a dead worker has nothing left to release. +pub fn release_php_handle(phandle: u64) -> anyhow::Result<()> { + let _session = session::SessionGuard::enter(); + send_frame(&Frame::ReleasePhpHandle { phandle }) +} + +/// Whether the PHP worker process has been spawned by this process. Callers that only need to +/// mirror state into an already-running worker (e.g. `InstalledVersions::reload` pushes) use +/// this to avoid spawning a worker that would have nothing to observe. +pub fn worker_is_running() -> bool { + WORKER_SPAWNED.load(Ordering::SeqCst) +} + fn rpc_call( request: impl FnOnce(u64) -> Frame, mut dispatcher: Option<&mut dyn RustMethodDispatcher>, @@ -499,6 +550,30 @@ const STUB_FILES: &[(&str, &str)] = &[ "Composer/Script/Event.php", include_str!("../php/stubs/Composer/Script/Event.php"), ), + ( + "Composer/PartialComposer.php", + include_str!("../php/stubs/Composer/PartialComposer.php"), + ), + ( + "Composer/Composer.php", + include_str!("../php/stubs/Composer/Composer.php"), + ), + ( + "Composer/IO/BaseIO.php", + include_str!("../php/stubs/Composer/IO/BaseIO.php"), + ), + ( + "Composer/IO/ConsoleIO.php", + include_str!("../php/stubs/Composer/IO/ConsoleIO.php"), + ), + ( + "Composer/IO/BufferIO.php", + include_str!("../php/stubs/Composer/IO/BufferIO.php"), + ), + ( + "Composer/IO/NullIO.php", + include_str!("../php/stubs/Composer/IO/NullIO.php"), + ), ]; struct Worker { @@ -530,11 +605,14 @@ impl Worker { // TODO(phase-c): a failed spawn panics rather than propagating a `Result`; this is an interim // step until PHP RPC gets proper error handling (see docs/dev/php-rpc.md). static WORKER: LazyLock<Mutex<Worker>> = LazyLock::new(|| { - Mutex::new( - spawn_worker().unwrap_or_else(|e| panic!("PHP RPC: failed to spawn PHP worker: {e:#}")), - ) + let worker = + spawn_worker().unwrap_or_else(|e| panic!("PHP RPC: failed to spawn PHP worker: {e:#}")); + WORKER_SPAWNED.store(true, Ordering::SeqCst); + Mutex::new(worker) }); +static WORKER_SPAWNED: AtomicBool = AtomicBool::new(false); + /// Writes one frame while holding the worker mutex only for the duration of the write, so the /// session owner (see `session`) can interleave sends and blocking reads without keeping the /// worker locked across a whole call. |