How LazyPromise is supposed to be used with Deferred?

[makasim]

I am performing an RPC call over MQ. and I'd like to return the control to the code that invoked my method. The $reply->receive() call must be postponed as long as possible. It is blokcing operation and it returns the result. I cannot call $deferred->resolve immidiatly so I am thinking of doing something with LazyPromise. Something like this:

<?php

public function __invoke(Message $message, Deferred $deferred = null):Promise
{
    // do some stuff which results in $reply var. 

        return new LazyPromise(function() use ($deferred, $reply) {
            try {
                $value = JSON::decode($reply->receive($this->replyTimeout)->getBody());

                $deferred->resolve($value);
            } catch (TimeoutException $e) {
                $deferred->reject($e->getMessage());
            }

            return $deferred->promise();
        });
    }

Is this the right way to go? Is there a better solution?

[clue]

Promises don't make your code async magically, you probably need to use an MQ adapter that is async itself, perhaps https://github.com/reactphp/react/wiki/Users may help?

In this case, the adapter would return a promise which you could simply return or react to without having to use a LazyPromise.

I hope this helps 👍

[codeliner]

@clue why magically? $reply->receive() is blocking, but not sending the message. Anyway, I guess answer is in the docs:

// $factory will only be executed once we call then()

https://github.com/reactphp/promise#lazypromise

So as soon as consumer of the LazyPromise attaches first then callback $reply->receive() gets called and will block execution.

I think @makasim is looking for a LazyPromise that executes the $factory on $promise->done(). So question is if something like that is doable somehow?

[makasim]

I read this If $value itself is a promise, the promise will transition to the state of this promise once it is resolved. in the deferred doc. Isn't it something I am looking for? I am setting lazy promise to deferred so its factory is called only when a callback is attached.

I dont need async I need $reply->receive() to be called as later as possible.

[clue]

@clue why magically? $reply->receive() is blocking, but not sending the message.

I'm not sure I follow exactly what you're trying to achieve here, so sorry if this didn't help with the issue you're seeing.

The issue here is still that ReactPHP isn't magic – it works under the assumption that blocking things get replaced with non-blocking counterparts. This means that in your above example, you would likely have to use an aync MQ adapter (see the users wiki for more details?) to take full advantage of ReactPHP.

In your particular case, not much is gained by wrapping it in a LazyPromise, as this is not how this works. This means that you can simply remove this instance and just resolve a deferred instead or use the promise primitives, such as React\Promise\resolve().

I hope this helps 👍

[codeliner]

I try with an example:

function performRPC(MQChannel $channel, array $queryMsg): Promise {
  //Non blocking RPC call, but no way to react on response only block and wait :(
  $reply = $channel->performRPCWithQuery($queryMsg);

  //Hence, blocking the process should be done as late as possible so we put it in a (Super)LazyPromise
  return new SuperLazyPromise(function() use ($reply) {
    $deferred = new Deferred();

    //Now we are blocking!
    $deferred->resolve($reply->receive());
    
    //Return already resolved deferred
    return $deferred;
  });
}

$asyncQuery = (new GetStatistics())->toArray();
$mqChannel = new RpcChannel();

/* @var SuperLazyPromise $promise */
$promise = performRPC($mqChannel, $asyncQuery);

//Function passed to SuperLazyPromise not called yet
$promise = $promise->then(/* chain RPC response handler */)
  ->then(/* chain another RPC response handler */); 

//Function passed to SuperLazyPromise still not called yet, RPC query is still in progress
$doSomeOther->work();

//From the docs: The intent of done() is to consume a promise's value, transferring responsibility for the value to your code.
//Nothing else to do except waiting for the statistics response
//So this would be a perfect time to call the function passed to SuperLazyPromise and the question is if we can achieve this when "done" is called instead of "then".
$rpcStatisticsResponse = $promise->done();

[codeliner]

Of course normally performRPC is not needed. You could just do it without react promises, but performRPC needs to fulfill a third party interface/contract that requires a react promise as return value. That is the reason why we're looking for way to do it with react promise ;)

@makasim Maybe you should just implement your own version of LazyPromise that calls the function/factory passed to it in the done method.

[clue]

If I follow what you're trying to do, it looks like this is what you're actually executing:

function performRPC(MQChannel $channel, array $queryMsg): Promise {
  $reply = $channel->performRPCWithQuery($queryMsg);
  return \React\Promise\resolve($reply->receive());

Is this what you actually want to do?

The above is clearly blocking – as long as your external call (RPC) is blocking. If you do not want to block, you need to use a non-blocking RPC call.

I hope this helps 👍

[codeliner]

@clue That's the point here. The RPC call is not blocking but waiting for the answer: $reply->receive() is blocking.

Same code snippet with slightly different method names ;)

function performRPC(MQChannel $channel, array $queryMsg): Promise {
  $reply = $channel->performNonBlockingRPCWithQuery($queryMsg);

  $doSome->work();

  $doEvenMore->work();

  return \React\Promise\resolve($reply->blockAndWaitUntilReceive());

Think of $reply like a promise but without then or done methods but instead a blocking receive method.

We want to do the other work outside of performRPC but it has to return a promise and start the RPC call. It should delay the $reply->blockAndWaitUntilReceive() call.

Anyway, as far as I know react promise does not provide a solution for that problem. A custom LazyPromise may solve the problem. We need to investigate on our end. Thx for your time @clue

[clue]

Anyway, as far as I know react promise does not provide a solution for that problem. A custom LazyPromise may solve the problem.

It looks like this is actually the issue here :-) Promises are about representing a placeholder for a future result of an operation, not about making this execute multiple things at once. Without having a deeper understanding of your code, it looks like it doesn't make sense to return a promise here from the function if its last statement is actually blocking. The short version is that you should never block the event-loop, the longer version is splitting blocking things off (for example into another process).