React Promise Rejection

[arunnabraham]

Hi team

While working on the ReactPHP HTTP client with MQ, I noticed one thing which I do not know whether it is a behavior or a bug.

My scenario is similar to

the following code.

<?php
$promise = React\Async\coroutine(function () {
    $browser = new React\Http\Browser();
    $urls = [
        'https://example.com/alice',
        'https://example.com/bob'
    ];

    $promises = [];
    foreach ($urls as $url) {
        $promises[] = $browser->get($url);
    }

    try {
        $responses = yield React\Promise\all($promises);
    } catch (Exception $e) {
        foreach ($promises as $promise) {
            $promise->cancel();
        }
        throw $e;
    }

    $bytes = 0;
    foreach ($responses as $response) {
        assert($response instanceof Psr\Http\Message\ResponseInterface);
        $bytes += $response->getBody()->getSize();
    }
    return $bytes;
});

$promise->then(function (int $bytes) {
    echo 'Total size: ' . $bytes . PHP_EOL;
}, function (Exception $e) {
    echo 'Error: ' . $e->getMessage() . PHP_EOL;
});

instead of looping Browser promise API directly, I use reactphp-mq promise for the result, Also I finally want to merge three different APIs like shown in the above example into one result. But the result appears to reject the whole set if any of the api is a reject.

Or if it process in sequence, the if it is success on first, that is accepted. But if the next iteration is a reject, then the consecutive onces also ignored.

I tried promise\all() and promise\any() api, both gives same result.

So my question is how are we able to get the response of all the non-rejected APIs?

[WyriHaximus]

It depends a bit on what you want to do with the 400/500 range responses. You can return the rejection of those via https://reactphp.org/http/#withrejecterrorresponse and I belive this show answer your question on how MQ handles rejections: https://github.com/clue/reactphp-mq/blob/1.x/src/Queue.php#L51-L54

P.S. Just wrapped your code block in highlight mode to make it easier to read.

[arunnabraham]

Thanks, @WyriHaximus, yeah this helped me by using withrejectresponse. So this scenario only happens with MQ? Never tried the async directly with the browser-api with default settings (without withrejectresponse)

BTW thank you again for the code highlighter.

[WyriHaximus]

Thanks, @WyriHaximus, yeah this helped me by using withrejectresponse. So this scenario only happens with MQ? Never tried the async directly with the browser-api with default settings (without withrejectresponse)

Not sure, depends a lot on the exact code and what you are trying to do tbh.

BTW thank you again for the code highlighter.

No problem!

[SimonFrings]

Hey @arunnabraham, thanks for sharing your code 👍

I'm interested in what you're trying to achieve with the shown example above. Understanding your use case helps me guiding you in the right direction and answering your questions (if you still have questions).

[arunnabraham]

Hi @SimonFrings, I am working on a project which shows the data imports include 3 set of APIs and a source api. this is collected on a local DB usually SQlite.

Earlier I was using direct data insert for each API using MQ, then merging the data. But that was much slower. So when I tested MQ with the async I could merge each set of API data together in a single array (memory) cutting my time in half for the entire process. (The merged array is treated as one row for a table).

Well this is just a brief workflow. Right now this is approach is helping me to rewrite a slow legacy codebase.

There are larger data in millions to achieve. Once this is done I need to focus on the stability (including a failsafe (API wait/retry) )approach.

Well, I have a few things on my mind to do Like wait and continue after a batch is done.

So to summarize this is about finding a balance between stability and race against time.

If you have a better strategy let me know, please. :)

[SimonFrings]

So when I tested MQ with the async I could merge each set of API data together in a single array (memory) cutting my time in half for the entire process.

Nice, this is what async is all about 👍
It can be complicated from time to time (especially with promises), that's why you might want to take a look at fibers with async() and await(), using our latest addition to ReactPHP: https://github.com/reactphp/async

There are larger data in millions to achieve. Once this is done I need to focus on the stability (including a failsafe (API wait/retry) )approach.

We use a similar approach when it comes to rewriting APIs or creating complete new ones. We focus on a specific improvement and making it work is our first priority. The stability part is achieved through writing tests, handling exception, covering edge cases etc.

So to summarize this is about finding a balance between stability and race against time.

Something we're also constantly aiming for 😀 If you have any question we're happy to help you out. We also helped developers through consulting sessions in the past if this is something you're interested in.