reactphp / child-process Goto Github PK

I ran into an edge case with child-process that I suspect may also affect stream. First of all, here is a reproduce case:

<?php

use React\ChildProcess\Process;
use React\EventLoop\Factory;
use React\EventLoop\LoopInterface;

require 'vendor/autoload.php';

function run(LoopInterface $loop, $cmd, callable $callback) {
    $process = new Process($cmd);

    $stdOut = '';
    $stdErr = '';

    $process->on(
        'exit',
        function ($exitCode) use ($callback, $cmd, &$stdOut, &$stdErr) {
            if ($exitCode) {
                throw new \Exception('Error running command ' . $cmd . ': ' . $exitCode . PHP_EOL . $stdOut . PHP_EOL . $stdErr);
            }

            $callback($stdOut);
        }
    );

    $process->start($loop);

    $process->stdout->on(
        'data',
        function ($output) use (&$stdOut) {
            $stdOut .= $output;
        }
    );
    $process->stderr->on(
        'data',
        function ($output) use (&$stdErr) {
            $stdErr .= $output;
        }
    );
}

function ssh($host, $cmd) {
    return 'ssh -o "PasswordAuthentication no" -A ' . escapeshellarg($host) . ' ' . escapeshellarg($cmd);
}

// list of 17 hosts to SSH into
$hosts = [...];

$attempts = 0;
while (true) {
    $attempts++;
    echo '.';
    if ($attempts % 60 === 0) {
        echo "\n";
    }

    // StreamSelectLoop
    $loop = Factory::create();

    foreach ($hosts as $host) {
        $loop->addTimer(
            0.001,
            function () use ($host, $loop, $attempts) {
                run($loop, ssh($host, 'echo foo'), function ($value) use ($attempts) {
                    if ($value !== "foo\n") {
                        throw new \Exception('Found bad value ' . json_encode($value) . ' after ' . $attempts . ' attempts');
                    }
                });
            }
        );
    }

    $loop->run();
}

The bad value returned here is an empty string.

I have been able to reproduce the problem in some cases without the timer and without the ssh command. But this is the most reliable reproduce case I have been able to come up with. On my local machine (running OSX) the problem is reproduced in 1-20 attempts. When running in a server environment it generally takes 20-200 attempts.

I managed to figure out that the process stdin's Stream::handleClose() is being called without the PHP stream's buffer being consumed.

A good way of seeing that is by replacing Stream::handleClose() with:

public function handleClose()
{
    if (is_resource($this->stream)) {
        $rest = stream_get_contents($this->stream);
        if ($rest !== '') {
            throw new \Exception($rest);
        }
        fclose($this->stream);
    }
}

You will see that the string "foo\n" was still in the buffer. And also get a backtrace to where the close() call came from.

Stream already waits for buffered writes to go out before closing. But it does not process buffered reads. I believe that is the source of the bug.

Enjoy!

Hi,

we are using this component for rector, currently, we currently have issue with spaced root project, that we have:

/Users/samsonasik/www/spaced prj sample/target/rector.php

and we want to change to:

/Users/samsonasik/www/spaced\ prj\ sample/target/rector.php

and this seems generaetd as double \\:

-/Users/samsonasik/www/spaced\ prj\ sample/target/rector.php
+/Users/samsonasik/www/spaced\\ prj\\ sample/target/rector.php

is this possible to be fixed here? Thank you.

Is it possible somehow to run PHPUnit Code Coverage on the process which is run with Process? In my application, I run a couple of PHP sub-processes of my code, but I want to check Code Coverage on that.

Hi guys,

I've been trying to use reactphp/child-process on Windows and I've had hard times having it to work.
I traced the problem back to a bug in PHP:

https://bugs.php.net/bug.php?id=51800

The bug has been solved, at least in recent PHP versions.

To sum it up:

I have an application that uses child-process and that works flawlessly on Linux.
On Windows, reactphp/child-process does not work with PHP 5.5.12. The PHP process stalls and nothing is happening (just like in the PHP bug)

It seems to work with PHP 5.6.6, although I'm having some strange behaviour (I'm facing locks of several seconds, then the application starts again...)

I've tried to run the unit tests of the master branch and many are failing in Windows. I'm not sure if those are supposed to work. Did you have any of those unit tests running on Windows? If yes, what version of PHP did you use?

Do you need some help working on that compatibility or is there something I missed?

The stdout and stderr stream pipes should emit an end/close event once their underlying stream ends. In particular, they should not emit a data event with an empty string.

In writing https://github.com/Vektah/phpunit-parallel I wanted to set up an additional pipe between the parent and child processes, but it seems there is currently no good way to do this.

We could add it to the constructor, but the constructor already has a bunch of arguments:

/**
    * Constructor.
    *
    * @param string $cmd     Command line to run
    * @param string $cwd     Current working directory or null to inherit
    * @param array  $env     Environment variables or null to inherit
    * @param array  $options Options for proc_open()
    * @throws RuntimeException When proc_open() is not installed
    */
    public function __construct($cmd, $cwd = null, array $env = null, array $options = array())

It really shouldn't be mutable state though otherwise cleanup could be broken and file descriptors could start leaking.

I'm happy to throw a PR up but I want to get some thoughts first.

Block of code in question:

        $fdSpec = array(
            array('pipe', 'r'), // stdin
            array('pipe', 'w'), // stdout
            array('pipe', 'w'), // stderr
            // I want to add additional pipes here. 
        );

enhanced sigchild support will also need to move down the appropriate number of file descriptors when new descriptors are added.

Hi,
I'm using a package (seregazhuk/php-watcher) that is based on reactphp/child-process

I'm trying to debug using xdebug the child process but it seems that when the process starts, no new "debugging socket" is being created as I was expecting.

I was trying to pass an explicit PHP-xdebug argument to start the debugger but it doesn't work.

I wanted to know whether I'm missing anything?

Thanks,
Niv

P.S - sorry for posting the issue with no body

Opening this as a FYI only, note that child processes inherit open file handles from the parent process.

https://bugs.php.net/bug.php?id=70932

Depending on how child processes are used this may or may not cause issues. I'm currently not aware of any issues in the ReactPHP ecosystem, so I'm merely opening this as a reminder and to gather some input on this.

One option would be adding a heads up to the README and consider this issue resolved for now. Thanks to @kelunik for making us aware of this issue!

Currently, all STDIO streams are exposed as duplex streams, which means that e.g. the $process->stdout->isWritable() returns true, which doesn't make much sense obviously.

Is it possible something similar to node cluster module

`cluster = require('cluster');
if (cluster.isMaster) {
cluster.fork();
cluster.on('fork', function(worker) {
newPID = worker.process.pid;
console.log(worker.process.pid);
});
cluster.on('exit', function(worker, code, signal) {
cluster.fork();
});
} 
if (cluster.isWorker) {
//create server here and logic to restart process with process.exit(1); 
}); 
}`

When we have child and master process and we could restart server with simple endpoint /restart in which we are calling process.exit(1) - ( in node.js this works properly )

I need to run a callback once the child process to stop to perform certain actions.

Also I need to pass arguments to the child process so that everything is run, I tried to pass the $conn object variable but it seems he does not accept it. How to resolve this?

What I have tried:

public function onOpen(ConnectionInterface $conn) {
    $callback = function () use ($conn) {
        echo "Hey, ".md5($conn->resourceId)."!\n";
    };

    $this->childProcess->stdin->write($conn, $callback);

He gave to understand what I'm trying to do? After passing the argument to the child process I want that callback is triggered and the user function md5 be used without blocking the process parents..

Do we need to set upper bound of react/stream to 0.5?

Let's face it, this project is currently beta, but has been used in production for years

We're currently following a v0.X.Y release scheme (http://sentimentalversioning.org/).

We should finally make this stable and fully adhere to SemVer and release a stable v1.0.0.

To a large extend, a stable v1.0.0 helps making BC breaks more explicit and thus the whole project more reliable from a consumer perspective. This project is actively maintained and has received some major updates in the last weeks and has some major updates planned in the next weeks. Given our current versioning scheme, we'd like to ensure all anticipated BC breaks will be merged before the planned v1.0.0 release.

As such, I've set up a roadmap that enlists only the major changes for each version among with planned release dates towards a stable v1.0.0 release:

v0.4.0 ✅

• Released 2014-07-31
• Initial tagged version

v0.4.1 ✅

• Released 2016-08-01
• Standalone component and tests

v0.4.2 ✅

• Released 2017-03-10
• Stream v0.5 API

v0.4.3 ✅

• Released 2017-03-14
• Support PHP 5.3 - PHP 7.1

v0.5.0 ✅

• Released 2017-08-15
• Readable/Writable pipes
• Drop Windows support entirely

v0.6.0 ✅

• Releases 2019-01-14
• Custom pipes
• Add (limited) Windows support

v0.7.0

• Planned 2022-Q1??
• API cleanup

v1.0.0

• Planned 2022-??
• No new changes planned, this should merely mark the previous release as "stable"

This ticket aims to serve as a basic overview and does not contain every single change. Please also see the milestone links and the CHANGELOG for more details.

Obviously, this roadmap is subject to change and I'll try to keep it updated as we progress. In order to avoid cluttering this, please keep discussion in this ticket to a minimum and consider reaching out to us through new tickets or Twitter etc.

If you put the phpinfo function in disabled_functions and try to use class Process with php8.0, it will throw the next error

PHP Fatal error: Uncaught Error: Call to undefined function phpinfo() in .../vendor/react/child-process/src/Process.php:373

There is the next code where it throw error attempting to call phpinfo function https://github.com/reactphp/child-process/blob/master/src/Process.php#L435

    /**
     * Return whether PHP has been compiled with the '--enable-sigchild' option.
     *
     * @see \Symfony\Component\Process\Process::isSigchildEnabled()
     * @return bool
     */
    public static final function isSigchildEnabled()
    {
        if (null !== self::$sigchild) {
            return self::$sigchild;
        }
        \ob_start();
        \phpinfo(\INFO_GENERAL);
        return self::$sigchild = \false !== \strpos(\ob_get_clean(), '--enable-sigchild');
    }

In the comments to the method there is a reference to a similar method from the Symfony class, where the disabled phpinfo state is provided https://github.com/symfony/symfony/blob/5.4/src/Symfony/Component/Process/Process.php#L1377

    protected function isSigchildEnabled()
    {
        if (null !== self::$sigchild) {
            return self::$sigchild;
        }

        if (!\function_exists('phpinfo')) {
            return self::$sigchild = false;
        }

        ob_start();
        phpinfo(\INFO_GENERAL);

        return self::$sigchild = false !== strpos(ob_get_clean(), '--enable-sigchild');
    }

Since phpinfo is disabled for security purposes in my case, is it possible to add this behavior?
Ready to send a Pull Request

Thank you for your time, checking this issue.

When I try to terminate the parent process with SIGINT (kill -2 parentPId), child processes are still running. I'm using signal handler for SIGINT in the parent class and there I call Process::terminate($singal). Child proccess ends only if I output something, for example if I uncomment echo PHP_EOL; in child.php

Code sample:

parent.php

<?php

use React\EventLoop\Factory;

require_once 'vendor/autoload.php';

$loop = Factory::create();

$startProcess = (function () use ($loop) {
    $process = new \React\ChildProcess\Process('php child.php');
    $process->start($loop);

    $process->stdout->on('data', function ($chunk) {
            echo $chunk;
    });

    return $process;
});

$processList = [
    $startProcess(),
    $startProcess()
];

$loop->addSignal(SIGINT, function ($signal) use ($processList, $loop) {
    foreach ($processList as $process) {
        foreach ($process->pipes as $pipe) {
            $pipe->close();
        }

        $process->terminate(SIGINT);
    }

    $loop->stop();
});


$loop->run();

child.php

<?php

require_once 'vendor/autoload.php';

$loop = \React\EventLoop\Factory::create();

$loop->addPeriodicTimer(1, function () {
    //echo PHP_EOL;
});

$loop->addSignal(SIGINT, function () use ($loop) {
    $loop->stop();
});

$loop->run();

Swoole's process abstraction uses a callback rather than calling exec, and then provides an exec method that can be used within the callback for executing commands if that's desired within the child process. See https://openswoole.com/docs/modules/swoole-process-construct . This gives the option of executing PHP code within the child process.

Every time a child process is created within PHP you fork the entire PHP instance, extensions and all. Yet to run any type of PHP within the reactphp child you need to call the the php/php-cli command which will than create yet another php instance, this one without access to any of the original parents resources. This is both inefficient and restrictive. Keep in mind that if the intent is to purposefully restrict the spawned php environment that php/php-cli can still be called via the exec method, as can other procedures to further reduce privileges of that process (if the parent process has privileges to do so).

I'm getting a segmentation fault error from my ratchet server while attempting to do

$process->stdin->write($json);

server is:

Ubuntu 14.4
PHP memory_limit = 128M
PHP 5.5.9

I'm using the following versions of ratchet and react child process

"cboden/ratchet": "^0.3.6",
"react/child-process": "^0.4.3"

code is working locally on os x and php 5.5.38

We may want to add a specific adapter taking advantage of libuv's process handling logic:

• http://docs.libuv.org/en/v1.x/process.html
• https://github.com/bwoebi/php-uv#resource-uv_spawnresource-loop-string-command-array-args-array-stdio-string-cwd-array-env--array-callable-callback-long-flags--array-options

To be clear, this project works just fine with all loop implementations, including the default StreamSelectLoop and ExtUvLoop. This potential adapter could take advantage of some of the optimizations inside libuv and avoid some of the known limitations of the project.

In particular, this may help with Windows support (#9) in the future because libuv supports pipes with overlapped mode on Windows. Note that a Windows build of ext-uv does not appear to be available at the time of writing this, but it is believed to change again in the future (amphp/ext-uv#63).

I'm trying to get in the event on data to verify if a thread has a specific string but it happens that when there are many strings printing with echo in the console or after printing the first string does not check me well.

I do not know if it is the correct way to obtain data from a childprocess but this is the method understood in the examples

$this->childprocess->stdout->on('data', function ($chunk) { if ($chunk == "/exit"){ echo $chunk; } });

also try it with trim ($ chunk)

at the beginning it works and the condition fulfills me but when the childprocess throws me a lot of data (many echo) it is lost and I do not know if it is the correct way to obtain data

On several distributions now phpinfo() no longer returns flag information. There needs to be a better way to detect whether --enable-sigchld was compiled in. Or, alternatively, it should be possible to tell the Process object constructor that it should be treated as enabled (so that the pipe trick can be used).

I'm using PHP from the IUS packages on CentOS 7. But I have read this is also a problem for Debian-based distributions.

The roadmap (#31) currently mentions "clean up API" for the v0.7.0 release, so I'm filing this ticket to discuss possible things that could be cleaned up.

Here's some of the things that I would like to address:

1.) The Process constructor and the start() method form a temporal dependence (you have to call start() exactly once after constructing). Additionally, because creating a process requires creating an instance of Process means that this is really hard to test in higher-level components that dynamically create the command for example (you can't inject a mock for instance, see https://github.com/clue/reactphp-ssh-proxy/blob/7ac2c246a1a5fd86246452d04346092cdd8bb1a7/src/SshProcessConnector.php#L89 for example). As an alternative, I would suggest adding a Launcher (name subject to discussion) which acts as a "factory" to create processes. This solves many of these problems, allows easily creating custom implementations for the points discussed below and also allows simply injecting a mock to higher-level implementations. Example usage:

// concept only
$launcher = new Launcher($loop);
$process = $launcher->launch('ping google.com');

$process->on('exit', 'var_dump');

2.) Inherited file descriptors (#51) are likely not what most use cases want. We should provide a "default launcher" which automatically takes care of closing all file descriptors. This can easily be integrated into the "launcher" concept above and we may or may not want to provide additional options to control this behavior.

3.) Windows support (#67) requires special care even for the easiest use cases. We should provide a "windows launcher" which automatically takes care of setting up I/O redirection for most common use cases. This can easily be integrated into the "launcher" concept above.

4.) The API is quite complex for common use cases. We should provide additional helper methods to cover common use cases. This can easily be integrated into the "launcher" concept above. For example, it's very common you only consume readable data from process output or want to buffer all the data:

// concept only
$launcher = new Launcher($loop);
$stream = $launcher->stream('ping example.com');

$stream->on('data', function ($chunk) {
    echo $chunk;
});


// concept only
$launcher = new Launcher($loop);
$promise = $launcher->buffer('ping example.com');

$promise->then(function ($data) {
    echo $data;
});

Any input is welcome! 👍

I was testing some stuff out with my library that i'm working on and found that sometimes if you run proc_close before proc_terminate PHP hangs. Did a quick google search and came across this: https://bugs.php.net/bug.php?id=34794

When close() is run possibly terminate?

We're currently moving forward with working on ReactPHP v3 and releasing the roadmap tickets for all our components (see reactphp/event-loop#271 and others). We still have some components that we haven't finalized plans for, especially with the next major version approaching. It's important to address how we can make sure these components are aligned with the upcoming ReactPHP v3.

To give some background information, the reactphp/child-process component is currently in version 0.6.5 and hasn't received a stable release yet. There is an open ticket describing the roadmap to a stable v1.0.0, which was opened back in August of 2017 and a lot has happened since then.

Needless to say, ChildProcess is still an important component for executing child processes with ReactPHP and will most definitely receive compatibility with the other v3 components. There's still the question when it will receive its own v3 and what about the outstanding stable v1.0.0?

Happy about input on this, so let's discuss possible options and decide on what makes the most sense 🚀

Is it possible to create a persistent connection to an IP over ssh and then be able to execute commands at will without having to ssh again?

I recently started optimizing phpunit process isolation. while doing research I found out, that proc_open can start processes with a lot less overhead when using a array argument.

would be great if we could use Process with a array argument, so we can start processes with less overhead in e.g. PHPStan