You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
284 lines
8.1 KiB
284 lines
8.1 KiB
<?php
|
|
|
|
/*
|
|
* This file is part of Psy Shell.
|
|
*
|
|
* (c) 2012-2020 Justin Hileman
|
|
*
|
|
* For the full copyright and license information, please view the LICENSE
|
|
* file that was distributed with this source code.
|
|
*/
|
|
|
|
namespace Psy\ExecutionLoop;
|
|
|
|
use Psy\Context;
|
|
use Psy\Exception\BreakException;
|
|
use Psy\Shell;
|
|
|
|
/**
|
|
* An execution loop listener that forks the process before executing code.
|
|
*
|
|
* This is awesome, as the session won't die prematurely if user input includes
|
|
* a fatal error, such as redeclaring a class or function.
|
|
*/
|
|
class ProcessForker extends AbstractListener
|
|
{
|
|
private $savegame;
|
|
private $up;
|
|
|
|
private static $pcntlFunctions = [
|
|
'pcntl_fork',
|
|
'pcntl_signal_dispatch',
|
|
'pcntl_signal',
|
|
'pcntl_waitpid',
|
|
'pcntl_wexitstatus',
|
|
];
|
|
|
|
private static $posixFunctions = [
|
|
'posix_getpid',
|
|
'posix_kill',
|
|
];
|
|
|
|
/**
|
|
* Process forker is supported if pcntl and posix extensions are available.
|
|
*
|
|
* @return bool
|
|
*/
|
|
public static function isSupported()
|
|
{
|
|
return self::isPcntlSupported() && !self::disabledPcntlFunctions() && self::isPosixSupported() && !self::disabledPosixFunctions();
|
|
}
|
|
|
|
/**
|
|
* Verify that all required pcntl functions are, in fact, available.
|
|
*/
|
|
public static function isPcntlSupported()
|
|
{
|
|
foreach (self::$pcntlFunctions as $func) {
|
|
if (!\function_exists($func)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Check whether required pcntl functions are disabled.
|
|
*/
|
|
public static function disabledPcntlFunctions()
|
|
{
|
|
return self::checkDisabledFunctions(self::$pcntlFunctions);
|
|
}
|
|
|
|
/**
|
|
* Verify that all required posix functions are, in fact, available.
|
|
*/
|
|
public static function isPosixSupported()
|
|
{
|
|
foreach (self::$posixFunctions as $func) {
|
|
if (!\function_exists($func)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Check whether required posix functions are disabled.
|
|
*/
|
|
public static function disabledPosixFunctions()
|
|
{
|
|
return self::checkDisabledFunctions(self::$posixFunctions);
|
|
}
|
|
|
|
private static function checkDisabledFunctions(array $functions)
|
|
{
|
|
return \array_values(\array_intersect($functions, \array_map('strtolower', \array_map('trim', \explode(',', \ini_get('disable_functions'))))));
|
|
}
|
|
|
|
/**
|
|
* Forks into a master and a loop process.
|
|
*
|
|
* The loop process will handle the evaluation of all instructions, then
|
|
* return its state via a socket upon completion.
|
|
*
|
|
* @param Shell $shell
|
|
*/
|
|
public function beforeRun(Shell $shell)
|
|
{
|
|
list($up, $down) = \stream_socket_pair(\STREAM_PF_UNIX, \STREAM_SOCK_STREAM, \STREAM_IPPROTO_IP);
|
|
|
|
if (!$up) {
|
|
throw new \RuntimeException('Unable to create socket pair');
|
|
}
|
|
|
|
$pid = \pcntl_fork();
|
|
if ($pid < 0) {
|
|
throw new \RuntimeException('Unable to start execution loop');
|
|
} elseif ($pid > 0) {
|
|
// This is the main thread. We'll just wait for a while.
|
|
|
|
// We won't be needing this one.
|
|
\fclose($up);
|
|
|
|
// Wait for a return value from the loop process.
|
|
$read = [$down];
|
|
$write = null;
|
|
$except = null;
|
|
|
|
do {
|
|
$n = @\stream_select($read, $write, $except, null);
|
|
|
|
if ($n === 0) {
|
|
throw new \RuntimeException('Process timed out waiting for execution loop');
|
|
}
|
|
|
|
if ($n === false) {
|
|
$err = \error_get_last();
|
|
if (!isset($err['message']) || \stripos($err['message'], 'interrupted system call') === false) {
|
|
$msg = $err['message'] ?
|
|
\sprintf('Error waiting for execution loop: %s', $err['message']) :
|
|
'Error waiting for execution loop';
|
|
throw new \RuntimeException($msg);
|
|
}
|
|
}
|
|
} while ($n < 1);
|
|
|
|
$content = \stream_get_contents($down);
|
|
\fclose($down);
|
|
|
|
if ($content) {
|
|
$shell->setScopeVariables(@\unserialize($content));
|
|
}
|
|
|
|
throw new BreakException('Exiting main thread');
|
|
}
|
|
|
|
// This is the child process. It's going to do all the work.
|
|
if (!@\cli_set_process_title('psysh (loop)')) {
|
|
// Fall back to `setproctitle` if that wasn't succesful.
|
|
if (\function_exists('setproctitle')) {
|
|
@\setproctitle('psysh (loop)');
|
|
}
|
|
}
|
|
|
|
// We won't be needing this one.
|
|
\fclose($down);
|
|
|
|
// Save this; we'll need to close it in `afterRun`
|
|
$this->up = $up;
|
|
}
|
|
|
|
/**
|
|
* Create a savegame at the start of each loop iteration.
|
|
*
|
|
* @param Shell $shell
|
|
*/
|
|
public function beforeLoop(Shell $shell)
|
|
{
|
|
$this->createSavegame();
|
|
}
|
|
|
|
/**
|
|
* Clean up old savegames at the end of each loop iteration.
|
|
*
|
|
* @param Shell $shell
|
|
*/
|
|
public function afterLoop(Shell $shell)
|
|
{
|
|
// if there's an old savegame hanging around, let's kill it.
|
|
if (isset($this->savegame)) {
|
|
\posix_kill($this->savegame, \SIGKILL);
|
|
\pcntl_signal_dispatch();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* After the REPL session ends, send the scope variables back up to the main
|
|
* thread (if this is a child thread).
|
|
*
|
|
* @param Shell $shell
|
|
*/
|
|
public function afterRun(Shell $shell)
|
|
{
|
|
// We're a child thread. Send the scope variables back up to the main thread.
|
|
if (isset($this->up)) {
|
|
\fwrite($this->up, $this->serializeReturn($shell->getScopeVariables(false)));
|
|
\fclose($this->up);
|
|
|
|
\posix_kill(\posix_getpid(), \SIGKILL);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create a savegame fork.
|
|
*
|
|
* The savegame contains the current execution state, and can be resumed in
|
|
* the event that the worker dies unexpectedly (for example, by encountering
|
|
* a PHP fatal error).
|
|
*/
|
|
private function createSavegame()
|
|
{
|
|
// the current process will become the savegame
|
|
$this->savegame = \posix_getpid();
|
|
|
|
$pid = \pcntl_fork();
|
|
if ($pid < 0) {
|
|
throw new \RuntimeException('Unable to create savegame fork');
|
|
} elseif ($pid > 0) {
|
|
// we're the savegame now... let's wait and see what happens
|
|
\pcntl_waitpid($pid, $status);
|
|
|
|
// worker exited cleanly, let's bail
|
|
if (!\pcntl_wexitstatus($status)) {
|
|
\posix_kill(\posix_getpid(), \SIGKILL);
|
|
}
|
|
|
|
// worker didn't exit cleanly, we'll need to have another go
|
|
$this->createSavegame();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Serialize all serializable return values.
|
|
*
|
|
* A naïve serialization will run into issues if there is a Closure or
|
|
* SimpleXMLElement (among other things) in scope when exiting the execution
|
|
* loop. We'll just ignore these unserializable classes, and serialize what
|
|
* we can.
|
|
*
|
|
* @param array $return
|
|
*
|
|
* @return string
|
|
*/
|
|
private function serializeReturn(array $return)
|
|
{
|
|
$serializable = [];
|
|
|
|
foreach ($return as $key => $value) {
|
|
// No need to return magic variables
|
|
if (Context::isSpecialVariableName($key)) {
|
|
continue;
|
|
}
|
|
|
|
// Resources and Closures don't error, but they don't serialize well either.
|
|
if (\is_resource($value) || $value instanceof \Closure) {
|
|
continue;
|
|
}
|
|
|
|
try {
|
|
@\serialize($value);
|
|
$serializable[$key] = $value;
|
|
} catch (\Throwable $e) {
|
|
// we'll just ignore this one...
|
|
} catch (\Exception $e) {
|
|
// and this one too...
|
|
// @todo remove this once we don't support PHP 5.x anymore :)
|
|
}
|
|
}
|
|
|
|
return @\serialize($serializable);
|
|
}
|
|
}
|