Can we check that current function/method is running in async() function?

[kodmanyagha]

Hi folks, I want to learn that how can I check that current method is running asynchronous or not. Example code here:

    /**
     * This method has to run as async. Because `await()` function is using here.
     * We can call this method without `async()` but this is causing some strange problems
     * when I use `await()` function. So there must be a method that allows us to check if
     * it is asynchronous or not. How can I do that?
     */
    protected function makeQueueSent(Queue $queueRow, $limitTime, $messageId): void
    {
        // I want to this kind of function/method/way...
        throwExceptionIfNotWeAreNotAsync();

        // update queue
        await($this->dbPool->query(
            "UPDATE queue SET status = 'sent', message_id = ? WHERE id = ? ",
            [(string)$messageId, (int)$queueRow->id]
        ));
    }

I didn't find any solution for this. If there is a way for doing this please write here. Thanks all.

[WyriHaximus]

Hey @kodmanyagha,

In short: No.

But more interestingly what are the issues you are seeing? And what is behind that dbPool?

[kodmanyagha]

Hi, thanks for your reply. dbPool is a pool which I found in somewhere friends-of-reactphp/mysql pull requests but I lost the PR link.

I created a gist which I'm using now:
https://gist.github.com/kodmanyagha/3416a9ed184d573fb9f8154431729795

[kodmanyagha]

I'm facing that problem: If any exception thrown in async function then the pool is running addTimer() function twice. Yes this is correct, it is calling addTimer() twice. In javascript we can call await in ONLY async functions, but in reactphp we can use await in both of async and non-async functions. This is causing some strange problems. Because of that we must be sure that current context is async. Or if it is possible you can add a control algorithm inside of await function.

[WyriHaximus]

Uhm there is no addTimer in that gist, so unsure what you are referring to. I'm also not doubting it is firing twice. However, I want to understand why that is happening and if we need to fix something on our end.

Also, when you're not spawning a fiber using async, you can still use await in the main fiber you run in by default. This however works best if you also have other fibers to switch back to. And as @SimonFrings also pointed out a bit further down, blocking the event loop can cause issues. And that logInfo function is suspicious to me.

[SimonFrings]

Hey @kodmanyagha, interesting question 👍

I'm not sure if there should be the need to check this as we should be able to tell from looking at the function. First of all, using the await($promise) function alone will block your code until the given $promise fulfills. This means you're currently blocking the execution when calling await($this->dbPool->query(...)) in your example above.

Wrapping the await() in an async() will still be considered blocking, but only inside your async() function. This might sound confusing, so let's take a look at an example from the https://github.com/reactphp/async documentation:

Loop::addTimer(0.5, React\Async\async(function () {
    echo 'a';
    React\Async\await(React\Promise\Timer\sleep(1.0));
    echo 'c';
}));

Loop::addTimer(1.0, function () {
    echo 'b';
});

// prints "a" at t=0.5s
// prints "b" at t=1.0s
// prints "c" at t=1.5s

Once we call the callback function of our first timer after 0.5 seconds, we print an "a" and then call the await() function. The await() now blocks the rest of the execution inside the async() function until its promise fulfills (promise will fulfill after sleeping 1 second), but we can work concurrent, which allows the second timer to fire after 1 second. This prints the "b". Once we finished sleeping for 1 second, we jump back into the async() function and print the "c".

When using the async() function, we use Fibers underneath. This means, once we call the async() function we start running a Fiber and if we call an await($promise) we'll suspend this Fiber and resume it once the $promise fulfills. This allows us to jump in and out of the async(). You could check with Fiber::getCurrent if you're currently executing a Fiber, but I don't want to suggest this as I'm not sure how much is really gained by this.

In your example above you describe using just the await() function causes "some strange problems", are there any error messages you're seeing or what is happening that leaves you with this conclusion.

I hope this helps a bit to understand how async() and await() works 👍

[kodmanyagha]

Hi, thanks for your reply. I'm getting ready some things, I will come back again.

[kodmanyagha]

Probably I found that how to detect the current function is called by async or not. I'm getting stack trace and looking the caller list, if closest caller is async() then no problem, otherwise I'm throwing exception.

Now, this is async() function implementation, namespace is React\Async. If we call anything in here, actually the Fiber::start() function will call our function and we will see this our stack trace.:

function async(callable $function): callable
{
    return static function (mixed ...$args) use ($function): PromiseInterface {
        $fiber = null;
        $promise = new Promise(function (callable $resolve, callable $reject) use ($function, $args, &$fiber): void {
            $fiber = new \Fiber(function () use ($resolve, $reject, $function, $args, &$fiber): void {
                try {
                    $resolve($function(...$args));
                } catch (\Throwable $exception) {
                    $reject($exception);
                } finally {
                    assert($fiber instanceof \Fiber);
                    FiberMap::unregister($fiber);
                }
            });

            FiberMap::register($fiber);

            $fiber->start();
...

This is example usage of async() function, don't forget to add parantheses after the async():

async(fn() => $this->fnMustCalledFromAsync())();

I think everybody can see the algorithm. Take a look to sureAsync() function now:

<?php
declare(strict_types=1);

namespace Tests\Feature;

use Exception;
use React\EventLoop\Loop;
use Tests\Base\DbInitializedTestCase;
use Throwable;
use function React\Async\async;
use function React\Async\await;
use function React\Promise\resolve;
use function React\Promise\Timer\sleep as rsleep;

class AsyncTest extends DbInitializedTestCase
{
    public function test_async_detect()
    {
        $loop = Loop::get();

        $loop->addTimer(0, function () {
            async(fn() => $this->exampleFn(1))(); // This works well.
            //$this->exampleFn(3); // This throws error.
        });

        $loop->run();

        // Test purpose, doesn't mean anything.
        $this->assertNotNull($loop);
    }

    /**
     * This is my solution. We must put this top of the necessary function.
     *
     * @throws Exception
     */
    protected function sureAsync(): void
    {
        $stackTrace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 4);
        //echo(json_encode($stackTrace, JSON_PRETTY_PRINT) . PHP_EOL . PHP_EOL);

        if (count($stackTrace) <= 2) {
            throw new Exception("You must call this function inside of a closure which called by async().");
        }

        $foundIndex = null;
        foreach ($stackTrace as $index => $item) {
            if ($index === 0) {
                continue;
            }

            if ($item["function"] === 'React\Async\{closure}') {
                $foundIndex = $index;
                break;
            }
        }

        if (is_null($foundIndex)) {
            throw new Exception("You must call this function inside of a closure which called by async() in " . $stackTrace[1]["file"] . ':' . $stackTrace[1]["line"]);
        }
    }

    /**
     * @throws Throwable
     */
    protected function exampleFn(int $no): void
    {
        // Now we can be sure with peace of mind that this function is called by `async()`.
        $this->sureAsync();

        logInfo($no . " function running.");

        // Actually fibers aren't solving our problem. Because even though we are not in async,
        // it brings the current fiber.
        //$fiber = Fiber::getCurrent();
        //if (is_null($fiber)) {
        //    logInfo($no . " fiber not found.");
        //} else {
        //    logInfo($no . " fiber found, is running: " . (int)$fiber->isRunning());
        //}

        // If we're not in async context rsleep() is throwing error.
        await(rsleep(1));
    }
}

[WyriHaximus]

@kodmanyagha Could be happening in logInfo, it's the only place in your example that isn't non-blocking for sure

[kodmanyagha]

It function contains print_r and these functions:

$stdout = fopen("php://stdout", "w");
fwrite($stdout, "\n" . $message . "\n\n");
fclose($stdout);

Is there a list of functions that block the event loop? Or how can we detect which function/class is blocking?

Edit: Actually in my real code I'm not using logInfo, I'm using that:

use Monolog\Logger;
use React\EventLoop\Loop;
use App\Services\Common\React\Monolog\StreamHandler;
use React\Stream\WritableResourceStream;

// ...

$logger = new Logger("app", [new StreamHandler(new WritableResourceStream(STDOUT, $loop))]);

Edit: As I know every function is blocking event loop, echo, print, creating a new object etc. Am I wrong? And one more question, can Fibers execute curl requests as async? What's difference between echo and curl functions? Why echo isn't blocking event loop but curl is blocking? What's difference?

[kodmanyagha]

@WyriHaximus @SimonFrings

[WyriHaximus]

Is there a list of functions that block the event loop? Or how can we detect which function/class is blocking?

Working on something to automate that, but in short anything that sleeps or does I/O one way or the other:

• (u)sleep
• file_(get|put)_contents/fread/etc
• gethostbyname

[SimonFrings]

Is there a list of functions that block the event loop? Or how can we detect which function/class is blocking?

What @WyriHaximus said above 👍

can Fibers execute curl requests as async

curl lets you exchange data between your device and a server through by sending HTTP requests. You can achieve the same thing by using the reactphp/http component and make use of Fibers by combining that with reactphp/async.

What's difference between echo and curl functions

Not sure if this is the place to ask these questions, as this should mostly focus on stuff related to ReactPHP, but in short the echo command in Linux is a built-in command that allows you to display lines of text or strings and the curl command is used to send out HTTP requests.