Http Client Pool and middleware

[vitsw]

I have to push a log middleware to the asynchronous requests. When I add a request to the Pool it initializes PendingRequest by calling setHandler() method and async() method. It means that the client is build, all handlers are pushed to the handlerStack and client is marked as reusable. So no middleware will be pushed to the handlerStack afterwards.

For example, those middleware won't be pushed to the handlerStack:

$responses = Http::pool(fn (Pool $pool) => [
    $pool->as('first')->withMiddleware(Middleware::log())->post('https://test1.com'),
    $pool->as('second')->withMiddleware(Middleware::log())->post('https://test2.com')
]);

Is it intended behavior? Is there some pitfalls with using middleware with async requests? Or it works in this way just because it was unnecessary feature?

[ousid]

Hi, @vitsw

Maybe you need to set the middleware before polling the request.?

$responses = Http::withMiddleware(Middleware::log)->poll(fn (Pool $pool) => [
    $pool->as('first')->post('https://test1.com'),
    $pool->as('second')->post('https://test2.com')
]);

[vitsw]

Hi, @ousid. Thanks for the reply. But this does not work either.

[ousid]

Hmm, are you sure that you registered the middleware in kernel.php file?

[vitsw]

It's a Guzzle Middleware not the one from the framework. It augments the functionality of handlers. For instance, I need to log every external request and response.

[ousid]

aaa yeah, I'm not familiar with Guzzle middlewares, thanks for the info Schwetz

[nevmerzhitsky]

The Pool class doesn't deliver $middleware content of the Http client instance while working with an array of requests, it only deliver a factory value:

    public function pool(callable $callback)
    {
        $results = [];

        $requests = tap(new Pool($this->factory), $callback)->getRequests();

        foreach ($requests as $key => $item) {
            $results[$key] = $item instanceof static ? $item->getPromise()->wait() : $item->wait();
        }

        return $results;
    }

Thus, any middleware before the pool() call "disappears" for the pool instance.

I treat this as a Laravel bug.

[vitsw]

When Http::pool($callback) is called it instantiates an instance of PendingRequest and calls its pool method passing the $callback through:

framework/src/Illuminate/Http/Client/Factory.php

Lines 390 to 392 in c275cdc

	return tap($this->newPendingRequest(), function ($request) {
	$request->stub($this->stubCallbacks);
	})->{$method}(...$parameters);

The pool method instantiates the Pool instance and calls the $callback passing the Pool instance as argument

framework/src/Illuminate/Http/Client/PendingRequest.php

Line 633 in c275cdc

$requests = tap(new Pool($this->factory), $callback)->getRequests();

So here we can add requests to the Pool

$responses = Http::withMiddleware(Middleware::log)->poll(fn (Pool $pool) => [
    $pool->as('first')->post('https://test1.com'),
    $pool->as('second')->post('https://test2.com')
]);

Pool instantiates new PendingRequest using asyncRequest() method which calls setHandler() and async() methods on it. After that pushes it to the internal $pool array.

framework/src/Illuminate/Http/Client/Pool.php

Lines 56 to 69 in c275cdc

	public function as(string $key)
	{
	return $this->pool[$key] = $this->asyncRequest();
	}
	/**
	* Retrieve a new async pending request.
	*
	* @return \Illuminate\Http\Client\PendingRequest
	*/
	protected function asyncRequest()
	{
	return $this->factory->setHandler($this->handler)->async();
	}

setHandler() method creates a guzzle client providing configured handlerStack

framework/src/Illuminate/Http/Client/PendingRequest.php

Lines 1088 to 1095 in c275cdc

	public function setHandler($handler)
	{
	$this->client = $this->createClient(
	$this->pushHandlers(HandlerStack::create($handler))
	);
	return $this;
	}

This is how handlerStack is configured. Some internal handler are pushed to the stack as well as middleware. Particulary when we add a request to the pool the setHandler() method is called on a fresh instance of the PendingRequest so the middleware collection is empty.

framework/src/Illuminate/Http/Client/PendingRequest.php

Lines 860 to 871 in c275cdc

	public function pushHandlers($handlerStack)
	{
	return tap($handlerStack, function ($stack) {
	$stack->push($this->buildBeforeSendingHandler());
	$stack->push($this->buildRecorderHandler());
	$stack->push($this->buildStubHandler());
	$this->middleware->each(function ($middleware) use ($stack) {
	$stack->push($middleware);
	});
	});
	}

After that async() method is called. It marks PendingRequest as async.

framework/src/Illuminate/Http/Client/PendingRequest.php

Lines 1012 to 1017 in c275cdc

	public function async(bool $async = true)
	{
	$this->async = $async;
	return $this;
	}

So at this point PendingRequest is configured (client is build and handlerStack is set up), marked as async and added to the Pool.

---

When Pool runs requests sendRequest() method is called on every request in a Pool. It builds guzzle client using buildClient() method and calls some method on it (ex. get,post etc.)

framework/src/Illuminate/Http/Client/PendingRequest.php

Lines 742 to 754 in c275cdc

	protected function sendRequest(string $method, string $url, array $options = [])
	{
	$clientMethod = $this->async ? 'requestAsync' : 'request';
	$laravelData = $this->parseRequestData($method, $url, $options);
	return $this->buildClient()->$clientMethod($method, $url, $this->mergeOptions([
	'laravel_data' => $laravelData,
	'on_stats' => function ($transferStats) {
	$this->transferStats = $transferStats;
	},
	], $options));
	}

So when request was marked async, it would reuse client which had been already created and configured in this case using setHandler() method. That means if we add middleware to the request they won't be pushed to the handlerStack.

framework/src/Illuminate/Http/Client/PendingRequest.php

Lines 803 to 828 in c275cdc

	public function buildClient()
	{
	return $this->requestsReusableClient()
	? $this->getReusableClient()
	: $this->createClient($this->buildHandlerStack());
	}
	/**
	* Determine if a reusable client is required.
	*
	* @return bool
	*/
	protected function requestsReusableClient()
	{
	return ! is_null($this->client) || $this->async;
	}
	/**
	* Retrieve a reusable Guzzle client.
	*
	* @return \GuzzleHttp\Client
	*/
	protected function getReusableClient()
	{
	return $this->client = $this->client ?: $this->createClient($this->buildHandlerStack());
	}

---

I've solved this by extending the Pool, but I am curious about the reasons it was designed in this way. Or may be I missed something.

[aliwesome]

@vitsw Could you please share you workaround for extending Pool class?

[madelson]

Will this be fixed? It seems like middleware should be able to work with pooled requests...

[nevmerzhitsky]

A workaround is simple: attach the middlewares inside the pool function callback to the $pool->as('...') call.

[madelson]

@nevmerzhitsky sorry can you explain/link a code snippet of what you mean

[aliwesome]

@vitsw Could you please share you workaround for extending Pool class?