Some notes on Promise / async guzzle

 Some notes on Promise / async

It works this way because calling tick when starting a promise could have the side effect of resolving other promises and resolving them. This could have pretty bad unforeseen consequences-- most of which revolve around unwanted recursion. Take the following example:

You are building a rate-limited pool of concurrent promises that yields promises from a generator. When a promise completes, the abstraction calls next on the generator, sends the request, and adds a promise to the pool. If initiating a promise in cURL caused other promises to complete, then it would cause the abstraction to attempt to call next on the generator while it's still yielding the previous value. This causes a strange sort of recursion in PHP generators and will trigger a fatal error.

You should either use the tick approach I mentioned in the comment linked by @Briareos or use a different adapter that hooks into an event loop in which your whole application is run asynchronously.

https://github.com/guzzle/guzzle/issues/1127

Unfortunately, calling tick() turned out to be not that simple.

In my case I have to execute tick() about 2-3 times until the request is actually sent.

As far as I understood, every while (curl_multi_exec() === CURLM_CALL_MULTI_PERFORM) loop performs some piece of work on registered handles.
My conjecture is that you can't say what exactly this piece of work will be. It's up to cURL and, probaly, is subject to changes.
Maybe first time it will establish connection, next time it will send data, and so on...

So, you can't be sure that your request will be fired on the very first curl_multi_exec() loop.

@drscre That's strange; I'm not a cURL expert, but when I look into the ext/curl source code, I see that curl_multi_exec is calling curl_multi_perform in libcurl, which says:

This function handles transfers on all the added handles that need attention in an non-blocking fashion.
When an application has found out there's data available for the multi_handle or a timeout has elapsed, the application should call this function to read/write whatever there is to read or write right now etc.

My interpretation is that all requests are sent at that point. Are you sure you are calling tick() only after all Client::xxxAsync() calls?

curl /kərl/

guzzle /ˈɡəzəl/

https://github.com/php-http/message/issues/96

https://stackoverflow.com/questions/45182654/upload-file-in-chunks-to-url-endpoint-using-guzzle-php

 $pathname = FCPATH . '../upload/Indus_at_Skardu.jpg';

        $api = env('DFC.URL') . '/api/uploadMedia';

        my_log($api);

        $resource = fopen($pathname, 'r');

        $stream = \GuzzleHttp\Psr7\Utils::tryFopen($pathname, 'r');

        $streamData =

        [

            'name' => 'file_upload',

            'contents' => $stream,

        ];

        $requestData = array_push($requestData, $streamData);

        $request = new \GuzzleHttp\Psr7\Request(

            'POST',

            $api,

            [],

            new \GuzzleHttp\Psr7\MultipartStream(

                [

                    [

                        'name' => 'file_upload',

                        'contents' => $stream,

                    ],

                    [

                        'name' => 'folderId',

                        'contents' => 2

                    ]

                ]

            )

        );

        $response = $this->guzzleHttpClient->send($request);

        my_log($response);