<form method="POST">
    <h3>Editing: CurlMultiHandler.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

namespace GuzzleHttp\Handler;

use GuzzleHttp\Promise as P;
use GuzzleHttp\Promise\Promise;
use GuzzleHttp\Promise\PromiseInterface;
use GuzzleHttp\Utils;
use Psr\Http\Message\RequestInterface;

/**
 * Returns an asynchronous response using curl_multi_* functions.
 *
 * When using the CurlMultiHandler, custom curl options can be specified as an
 * associative array of curl option constants mapping to values in the
 * **curl** key of the provided request options.
 *
 * @final
 */
class CurlMultiHandler
{
    /**
     * @var CurlFactoryInterface
     */
    private $factory;

    /**
     * @var int
     */
    private $selectTimeout;

    /**
     * @var int Will be higher than 0 when `curl_multi_exec` is still running.
     */
    private $active = 0;

    /**
     * @var array Request entry handles, indexed by handle id in `addRequest`.
     *
     * @see CurlMultiHandler::addRequest
     */
    private $handles = [];

    /**
     * @var array&lt;int, float&gt; An array of delay times, indexed by handle id in `addRequest`.
     *
     * @see CurlMultiHandler::addRequest
     */
    private $delays = [];

    /**
     * @var array&lt;mixed&gt; An associative array of CURLMOPT_* options and corresponding values for curl_multi_setopt()
     */
    private $options = [];

    /** @var resource|\CurlMultiHandle */
    private $_mh;

    /**
     * This handler accepts the following options:
     *
     * - handle_factory: An optional factory  used to create curl handles
     * - select_timeout: Optional timeout (in seconds) to block before timing
     *   out while selecting curl handles. Defaults to 1 second.
     * - options: An associative array of CURLMOPT_* options and
     *   corresponding values for curl_multi_setopt()
     */
    public function __construct(array $options = [])
    {
        $this-&gt;factory = $options['handle_factory'] ?? new CurlFactory(50);

        if (isset($options['select_timeout'])) {
            $this-&gt;selectTimeout = $options['select_timeout'];
        } elseif ($selectTimeout = Utils::getenv('GUZZLE_CURL_SELECT_TIMEOUT')) {
            @trigger_error('Since guzzlehttp/guzzle 7.2.0: Using environment variable GUZZLE_CURL_SELECT_TIMEOUT is deprecated. Use option &quot;select_timeout&quot; instead.', \E_USER_DEPRECATED);
            $this-&gt;selectTimeout = (int) $selectTimeout;
        } else {
            $this-&gt;selectTimeout = 1;
        }

        $this-&gt;options = $options['options'] ?? [];

        // unsetting the property forces the first access to go through
        // __get().
        unset($this-&gt;_mh);
    }

    /**
     * @param string $name
     *
     * @return resource|\CurlMultiHandle
     *
     * @throws \BadMethodCallException when another field as `_mh` will be gotten
     * @throws \RuntimeException       when curl can not initialize a multi handle
     */
    public function __get($name)
    {
        if ($name !== '_mh') {
            throw new \BadMethodCallException(&quot;Can not get other property as '_mh'.&quot;);
        }

        $multiHandle = \curl_multi_init();

        if (false === $multiHandle) {
            throw new \RuntimeException('Can not initialize curl multi handle.');
        }

        $this-&gt;_mh = $multiHandle;

        foreach ($this-&gt;options as $option =&gt; $value) {
            // A warning is raised in case of a wrong option.
            curl_multi_setopt($this-&gt;_mh, $option, $value);
        }

        return $this-&gt;_mh;
    }

    public function __destruct()
    {
        if (isset($this-&gt;_mh)) {
            \curl_multi_close($this-&gt;_mh);
            unset($this-&gt;_mh);
        }
    }

    public function __invoke(RequestInterface $request, array $options): PromiseInterface
    {
        $easy = $this-&gt;factory-&gt;create($request, $options);
        $id = (int) $easy-&gt;handle;

        $promise = new Promise(
            [$this, 'execute'],
            function () use ($id) {
                return $this-&gt;cancel($id);
            }
        );

        $this-&gt;addRequest(['easy' =&gt; $easy, 'deferred' =&gt; $promise]);

        return $promise;
    }

    /**
     * Ticks the curl event loop.
     */
    public function tick(): void
    {
        // Add any delayed handles if needed.
        if ($this-&gt;delays) {
            $currentTime = Utils::currentTime();
            foreach ($this-&gt;delays as $id =&gt; $delay) {
                if ($currentTime &gt;= $delay) {
                    unset($this-&gt;delays[$id]);
                    \curl_multi_add_handle(
                        $this-&gt;_mh,
                        $this-&gt;handles[$id]['easy']-&gt;handle
                    );
                }
            }
        }

        // Step through the task queue which may add additional requests.
        P\Utils::queue()-&gt;run();

        if ($this-&gt;active &amp;&amp; \curl_multi_select($this-&gt;_mh, $this-&gt;selectTimeout) === -1) {
            // Perform a usleep if a select returns -1.
            // See: https://bugs.php.net/bug.php?id=61141
            \usleep(250);
        }

        while (\curl_multi_exec($this-&gt;_mh, $this-&gt;active) === \CURLM_CALL_MULTI_PERFORM) {
        }

        $this-&gt;processMessages();
    }

    /**
     * Runs until all outstanding connections have completed.
     */
    public function execute(): void
    {
        $queue = P\Utils::queue();

        while ($this-&gt;handles || !$queue-&gt;isEmpty()) {
            // If there are no transfers, then sleep for the next delay
            if (!$this-&gt;active &amp;&amp; $this-&gt;delays) {
                \usleep($this-&gt;timeToNext());
            }
            $this-&gt;tick();
        }
    }

    private function addRequest(array $entry): void
    {
        $easy = $entry['easy'];
        $id = (int) $easy-&gt;handle;
        $this-&gt;handles[$id] = $entry;
        if (empty($easy-&gt;options['delay'])) {
            \curl_multi_add_handle($this-&gt;_mh, $easy-&gt;handle);
        } else {
            $this-&gt;delays[$id] = Utils::currentTime() + ($easy-&gt;options['delay'] / 1000);
        }
    }

    /**
     * Cancels a handle from sending and removes references to it.
     *
     * @param int $id Handle ID to cancel and remove.
     *
     * @return bool True on success, false on failure.
     */
    private function cancel($id): bool
    {
        if (!is_int($id)) {
            trigger_deprecation('guzzlehttp/guzzle', '7.4', 'Not passing an integer to %s::%s() is deprecated and will cause an error in 8.0.', __CLASS__, __FUNCTION__);
        }

        // Cannot cancel if it has been processed.
        if (!isset($this-&gt;handles[$id])) {
            return false;
        }

        $handle = $this-&gt;handles[$id]['easy']-&gt;handle;
        unset($this-&gt;delays[$id], $this-&gt;handles[$id]);
        \curl_multi_remove_handle($this-&gt;_mh, $handle);
        \curl_close($handle);

        return true;
    }

    private function processMessages(): void
    {
        while ($done = \curl_multi_info_read($this-&gt;_mh)) {
            if ($done['msg'] !== \CURLMSG_DONE) {
                // if it's not done, then it would be premature to remove the handle. ref https://github.com/guzzle/guzzle/pull/2892#issuecomment-945150216
                continue;
            }
            $id = (int) $done['handle'];
            \curl_multi_remove_handle($this-&gt;_mh, $done['handle']);

            if (!isset($this-&gt;handles[$id])) {
                // Probably was cancelled.
                continue;
            }

            $entry = $this-&gt;handles[$id];
            unset($this-&gt;handles[$id], $this-&gt;delays[$id]);
            $entry['easy']-&gt;errno = $done['result'];
            $entry['deferred']-&gt;resolve(
                CurlFactory::finish($this, $entry['easy'], $this-&gt;factory)
            );
        }
    }

    private function timeToNext(): int
    {
        $currentTime = Utils::currentTime();
        $nextTime = \PHP_INT_MAX;
        foreach ($this-&gt;delays as $time) {
            if ($time &lt; $nextTime) {
                $nextTime = $time;
            }
        }

        return ((int) \max(0, $nextTime - $currentTime)) * 1000000;
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>