use Psr\Http\Message\ServerRequestInterface;
use React\Http\Response;
use React\Promise\Promise;
use function \Clue\React\Block\await;

require_once 'vendor/autoload.php';

$loop = new \React\EventLoop\ExtEventLoop;
//$loop = new \React\EventLoop\StreamSelectLoop;
//$loop = \React\EventLoop\Factory::create();

echo 'Loop lib: ' . get_class($loop) . PHP_EOL;

$server = new \React\Http\Server(function (ServerRequestInterface $request) use ($loop) {
    $promise = new Promise(function (callable $resolve) use ($loop) {
        $loop->addTimer(10, function () use ($resolve) {
            $resolve('async done');
        });
    });

    $result = await($promise, $loop);
    return new Response(200, ['Content-Type' => 'text/plain'], $result);
});

$socket = new \React\Socket\Server(8080, $loop);
$server->listen($socket);

$loop->run();

Warning: EventBase::loop(): event_base_loop: reentrant invocation. Only one event_base_loop can run on each event_base at once. in /Users/alex/www/alex/php-crop-service/vendor/react/event-loop/src/ExtEventLoop.php on line 204

It dont work on ExtEventLoop, only StreamSelectLoop.

Do you have idea how fix it?

hello ,

I use guzzle library , react promise , block react. my problem is that the system loops infinitely when I call as following

       $loop = React\EventLoop\Factory::create();
        $requestPromise = $this->sendMessageTravelportApi($requestXml, $endpoint);
        $responseXml = Clue\React\Block\await($requestPromise, $loop);

the requestPromise as following:

 $requestDeferred = new React\Promise\Deferred();
        $requestParams = new Request("POST", $endpoint, $header, $message);
        $client = new Client();
        $client->sendAsync($requestParams)->then(
                function (ResponseInterface $res) use($requestDeferred) {
            // $res->getStatusCode() . "\n";
            $requestDeferred->resolve($res->getBody()->getContents());
        }, function (RequestException $e) use($requestDeferred) {
            $requestDeferred->reject();
        });
        return $requestDeferred->promise();

So I cant find why system loops infinitely.

Calling await*() with no timeout is scary. I think that in almost all cases, when we wait for something we don't want to potentially wait forever. While clients of this library could handle this themselves, it's much easier to add it to this library directly.

Regarding the implementation: it might make sense to have a TimeoutException class to make it easier for clients to differentiate between rejected promises and timeouts.

It's totally cool if you don't want to merge this!

In case you use pthreads or something else related to threading you might encounter this issue. It happens only with functions and is fixable only by adding these checks. Another way to avoid this is to wrap functions as static into classes.

Hi,

I have a following use case:

I'm using php-pm for request-response flow with psr7-adapter. So, my main class (application) is invoked with PSR7 request and response objects as any other middleware. An expected return value for middleware must be an instance of PSR7-Response. Since I'm using React HTTP client to call some APIs in my app I'm forced to use php-block-react so the PSR7-Response will be returned after all promises are done and data from APIs will be placed in PSR7-Response mentioned above. In simple words:

1. I receive PSR7-Request
2. I run few promises to call external APIs
3. I set await function to wait for all promises and block returning empty PSR7-Response
4. I parse promises response and fill my PSR7-Response with proper data
5. I return ready PSR7-Response object

I hope all here is clear and now my issue ;)

await function calls $loop->run() internally for obvious reasons. After all conditions for await functions are meet (promises fulfilled), the $loop->stop() is called (I also understand why it must be done like that). So, after await function my main React loop is turned off and my whole application is shutted down, since there is now way to turn React loop on again. Below I post simple example (different code, but the same principle):

{
  "name": "vendor_name/package_name",
  "description": "description_text",
  "minimum-stability": "stable",
  "license": "proprietary",
  "authors": [
    {
      "name": "author's name",
      "email": "[email protected]"
    }
  ],
  "require": {
    "clue/block-react": "^1.1.0"
  }
}

<?php

require_once 'vendor/autoload.php';

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

// postpone await, so main loop can be started
$loop->addTimer(0.5, function () use ($loop) {
    $promise = \React\Promise\Timer\resolve(6, $loop);
    $promise = $promise->then(function() {
        echo 'timer promise done' . PHP_EOL;
    });

    echo 'await loop start' . PHP_EOL;
    \Clue\React\Block\await($promise, $loop);
    echo 'await loop end' . PHP_EOL;
});

$loop->addPeriodicTimer(1, function() {
    echo 'test' . time() . PHP_EOL;
});

echo 'main loop start' . PHP_EOL;
$loop->run();
echo 'main loop end' . PHP_EOL;

I resolved this by creating second, internal React loop to handle every new request. By this I gain possibility to shutdown only internal loop (not the whole app), but in the time of processing request (and all external API calls), my main React loop is blocked, so obviously not a great, final solution :/

Any help is appreciated, maybe I'm doing something totally wrong here :/ Maybe I'm doing all right, this library is also totally correct, but the problem lies in absence of $loop->resume() function which will set $loop->running = true as stop() method sets it to false.

I needed to wait for a promise while already within a loop. Because the await() function calls $loop->stop(), the loop I was already in stopped.

I removed $loop->stop() and instead of $loop->run() I now call $loop->tick(). This has resolved my problem. The unittests are still working as well.

Please let me know about any problems with this approach, I will try to resolve them.

Hi there,

i have a bunch of curl calls that i want to finish before i process further to save memory while processing a lot of data. But somehow block halts everything for infinite time, so nothing happens anymore.

Even with trying it in a simple testcase with one curl request and awaitOne didn't work.

I am not sure if that is a issue because of as mistake on my part or if reactphp-curl is incompatible with block. I would be gratefull if you could help me to work this issue out.

Best regards and have a nice day.

Shortly after using any of the functions (await, awaitAll, even sleep) the app stops. It simply finishes when the current stack is done. If I remove the \Block function and replace it with a dummy, it works just fine. Even when I don't remove it, it works as expected, the promise resolves successfully and it's returned properly. But when the loop goes to the end, it stops, I presume because of the loop->stop() part in the source.

Am I doing something wrong? Any suggestions would be appreciated.

"react/event-loop": "^1.1" "clue/block-react": "^1.3"

PHP 7.2.24-0ubuntu0.19.04.1 (cli) (built: Oct 24 2019 11:49:39) ( NTS )

Currently block relies on a while call to check if a flag has changed in order to implement async blocking. This may result in a busy loop wasting CPU cycles.

There are alternatives to doing this. One can use a flock and block on the lock, this makes use of the OS locking mechanism to prevent busy looping. Another way is to use one of the process control extensions: http://php.net/manual/en/refs.fileprocess.process.php

While the above 2 work. The former needs a lock file (which is not always readily available), the latter requires installing extensions which is not always available.

A third way is to use http://php.net/manual/en/function.stream-select.php however this ideally should be paired up with the unix pipe call. But there doesn't seem to be a PHP wrapper for the anonymous pipe call, a discussion was formed here: https://bugs.php.net/bug.php?id=60896

However an alternative is real sockets which is provided by native PHP: http://php.net/manual/en/function.socket-create-pair.php and http://php.net/manual/en/function.socket-select.php

So combining the 2 together, we can create a non-busy loop for the async to sync conversion.

I'm having some difficulty using Block\await function in reactphp codes. I implemented this issue in 3 ways but either way it failed to do my task!

Number 1

It will execute correctly but it close the connection and stops server

public function awaitLottieResizer($amount, $asset)
    {
        try {
            $fun =  aPromiseFunction(); // it will return PromiseInterface
            return await($fun);
        } catch (\Exception $e) {
            return "Exception";
        }
    }

Number 2

It won't return anything and code stuck but the server is running

public function awaitLottieResizer($amount, $asset)
    {
        try {
            $fun =  aPromiseFunction(); // it will return PromiseInterface
            return await($fun, null);
        } catch (\Exception $e) {
            return "Exception";
        }
    }

Number 3

It won't return anything and code stuck but the server is running

public function awaitLottieResizer($amount, $asset)
    {
        try {
            $fun =  aPromiseFunction(); // it will return PromiseInterface
            return await($fun, React\EventLoop\Loop::get());
        } catch (\Exception $e) {
            return "Exception";
        }
    }

Block\sleep usage can be a little bit confusing, so the loop is not blocked, but it is your program execution. In terms of non-blocking architecture, what I understand of an sleep is a Promise resolved after N seconds, From the developer POV, is nice to have this warning here.

If you're currently using this project, you may want to check out the successor https://github.com/reactphp/async instead 🎉 We've merged the await() function from this project into the new react/async package without the optional parameters $loop and $timeout. Upgrading should still be simple and should take no longer than a few minutes in most cases:

// old
$result = Clue\React\Block\await($promise);

// new
$result = React\Async\await($promise);

This project may see some smaller adjustments / fixes in the future, but all development efforts and new features will focus on react/async instead. Upgrading is highly recommended.

We're planning to soft-deprecate this project in the future after a reasonable transition period. We want to ensure a smooth upgrade path and will not break any existing implementations, so you can keep installing old versions from this project, but should not expect any major changes and feature additions.

Head over to https://github.com/reactphp/async!

Refs: https://github.com/reactphp/async/pull/8 This ticket is similar to https://github.com/clue/reactphp-buzz/issues/177 by @clue.