BodyResponse promise is not resolving

[g105b]

Here's a sample program:

<?php
require(__DIR__ . "/vendor/autoload.php");

use Gt\Fetch\Http;
use Gt\Fetch\BodyResponse;

$http = new Http();

$http->fetch("http://atlas.srv.brightflair.com/slow.php?i=1&num=2000")
->then(function(BodyResponse $response) {
        if($response->ok) {
                echo "Response 1 OK. Getting text..." . PHP_EOL;
                return $response->text();
        }
})
->then(function(string $text) {
        echo "Full response 1 is " . strlen($text) . " bytes!" . PHP_EOL;
});

$http->wait();

echo "The script has completed. Has the final callback been called?";

The RequestResolver class works a treat. The BodyResponse is resolved as soon as the headers come back from the Curl request, so when "Response 1 OK. Getting text..." is written, the body contents is still streaming in via the React loop.

The problem is that even though the BodyResponse is resolved (see snippet below), the outer Promise never resolves.

This runs: https://github.com/PhpGt/fetch/blob/97aaaae4f4b78dae921cca262534a885b92acbab/src/BodyResponse.php#L58-L68 , but the final ->then does not run.

[g105b]

A bit more detail about what's going on behind the scenes:

When $http->fetch is called at the top of our program, it created the React "deferred" and "deferred promise" objects (which are fantastic implementations of the Promise spec). It then adds these deferred promise objects to the RequestResolver . The RequestResolver is an object that can have many deferred promises added to it, and then a React Loop is started that calls the RequestResolver::tick function multiple times per second.

Within the tick function, the curl requests are checked for any incoming messages, and the messages are send to the write and writeHeader functions.

The idea is that a RequestResolver can have multiple Curl requests on the go at the same time. Only when all Curl requests are complete, does the loop end. Check the logic here: https://github.com/PhpGt/fetch/blob/97aaaae4f4b78dae921cca262534a885b92acbab/src/RequestResolver.php#L133

All of the above works a treat. Debugging this shows that the write and writeHeader functions are called when any bytes are available in the stream, and the loop ends when it should just fine.

So, the promise that's returned from the main Http::fetch function resolves fine, and the BodyResponse object is passed to the callback just fine.

Within that callback, another response is returned by calling the $response->text() function. This is part of the Fetch spec -- the rationale being that you want the first callback to return A.S.A.P., so you can check its response code, etc. but the response body might be very large, and might be a long time until it is downloaded. From here, you can access the stream directly, or in our case, call the text() function to register a new Promise to be resolved with the whole body response text.

This is where the problem lies. You can tell by debugging the RequestResolver::write function that the data is coming in correctly, and you can see that yourself by just timing how long the program runs for (the example URL in the example above is intentionally slow). However, the final promise simply does not resolve, and I can't work out why this is.

The whole code within this repository is really short, so it shouldn't take you too long to get to grips with the flow of code. I believe the issue is due to wrapping the React Promise with a PSR promise... which I'll explain here:

I wanted to make this library compatible with PHP-HTTP (which used to be called HTTP-Plug, and is somehow involved with PHP-FIG's PSRs...) because it's an upcoming standard with a good benefit. If an HTTP library is compatible with PHP-HTTP, it can be swapped out with any other compatible library. That's a really nice idea, so I definitely wanted to work with that.

PHP-HTTP only defines interfaces, and lets you implement them. Details on PHP-HTTP here: http://docs.php-http.org/en/latest/components/promise.html

The only confusion this caused is that PHP-HTTP specifies its own Promise interface, which the React Promises are not currently compatible with. So I have had to wrap the React promise with a Gt\Fetch\Promise, which does implement the PHP-HTTP spec, and is intended to resolve as soon as the React promise resolves... working kind of like an Adapter Pattern.

Phew... this was a long message. Hope it helps you!

[g105b]

Here's a better test program to run. It starts two purposefully-slow HTTP requests. The second request will complete before the first.

use Gt\Fetch\Http;
use Gt\Fetch\BodyResponse;

$http = new Http();

$http->fetch("http://atlas.srv.brightflair.com/slow.php?i=1&num=4000")
->then(function(BodyResponse $response) {
	if($response->ok) {
		echo "Response 1 OK. Getting text..." . PHP_EOL;
		return $response->text();
	}
	else {
		echo "Response 1 NOT OK!" . PHP_EOL;
		return null;
	}
})
->then(function(string $text) {
	echo "Full response 1 is " . strlen($text) . " bytes!" . PHP_EOL;
});

$http->fetch("http://atlas.srv.brightflair.com/slow.php?i=1&num=2000")
->then(function(BodyResponse $response) {
	if($response->ok) {
		echo "Response 2 OK. Getting text..." . PHP_EOL;
		return $response->text();
	}
	else {
		echo "Response 2 NOT OK!" . PHP_EOL;
		return null;
	}
})
->then(function(string $text) {
	echo "Full response 2 is " . strlen($text) . " bytes!" . PHP_EOL;
});

$http->wait();

echo "The script has completed. Has the final callback been called?";

[g105b]

Fixed in latest release!