nextcloud / fulltextsearch_elasticsearch

lib/Vendor/GuzzleHttp/MessageFormatter.php

Indentation +129 added lines, -129 removed lines

@@ -36,133 +36,133 @@
  */
 class MessageFormatter implements MessageFormatterInterface
 {
-    /**
-     * Apache Common Log Format.
-     *
-     * @see https://httpd.apache.org/docs/2.4/logs.html#common
-     *
-     * @var string
-     */
-    public const CLF = '{hostname} {req_header_User-Agent} - [{date_common_log}] "{method} {target} HTTP/{version}" {code} {res_header_Content-Length}';
-    public const DEBUG = ">>>>>>>>\n{request}\n<<<<<<<<\n{response}\n--------\n{error}";
-    public const SHORT = '[{ts}] "{method} {target} HTTP/{version}" {code}';
-    /**
-     * @var string Template used to format log messages
-     */
-    private $template;
-    /**
-     * @param string $template Log message template
-     */
-    public function __construct(?string $template = self::CLF)
-    {
-        $this->template = $template ?: self::CLF;
-    }
-    /**
-     * Returns a formatted message string.
-     *
-     * @param RequestInterface       $request  Request that was sent
-     * @param ResponseInterface|null $response Response that was received
-     * @param \Throwable|null        $error    Exception that was received
-     */
-    public function format(RequestInterface $request, ?ResponseInterface $response = null, ?\Throwable $error = null) : string
-    {
-        $cache = [];
-        /** @var string */
-        return \preg_replace_callback('/{\\s*([A-Za-z_\\-\\.0-9]+)\\s*}/', function (array $matches) use($request, $response, $error, &$cache) {
-            if (isset($cache[$matches[1]])) {
-                return $cache[$matches[1]];
-            }
-            $result = '';
-            switch ($matches[1]) {
-                case 'request':
-                    $result = Psr7\Message::toString($request);
-                    break;
-                case 'response':
-                    $result = $response ? Psr7\Message::toString($response) : '';
-                    break;
-                case 'req_headers':
-                    $result = \trim($request->getMethod() . ' ' . $request->getRequestTarget()) . ' HTTP/' . $request->getProtocolVersion() . "\r\n" . $this->headers($request);
-                    break;
-                case 'res_headers':
-                    $result = $response ? \sprintf('HTTP/%s %d %s', $response->getProtocolVersion(), $response->getStatusCode(), $response->getReasonPhrase()) . "\r\n" . $this->headers($response) : 'NULL';
-                    break;
-                case 'req_body':
-                    $result = $request->getBody()->__toString();
-                    break;
-                case 'res_body':
-                    if (!$response instanceof ResponseInterface) {
-                        $result = 'NULL';
-                        break;
-                    }
-                    $body = $response->getBody();
-                    if (!$body->isSeekable()) {
-                        $result = 'RESPONSE_NOT_LOGGEABLE';
-                        break;
-                    }
-                    $result = $response->getBody()->__toString();
-                    break;
-                case 'ts':
-                case 'date_iso_8601':
-                    $result = \gmdate('c');
-                    break;
-                case 'date_common_log':
-                    $result = \date('d/M/Y:H:i:s O');
-                    break;
-                case 'method':
-                    $result = $request->getMethod();
-                    break;
-                case 'version':
-                    $result = $request->getProtocolVersion();
-                    break;
-                case 'uri':
-                case 'url':
-                    $result = $request->getUri()->__toString();
-                    break;
-                case 'target':
-                    $result = $request->getRequestTarget();
-                    break;
-                case 'req_version':
-                    $result = $request->getProtocolVersion();
-                    break;
-                case 'res_version':
-                    $result = $response ? $response->getProtocolVersion() : 'NULL';
-                    break;
-                case 'host':
-                    $result = $request->getHeaderLine('Host');
-                    break;
-                case 'hostname':
-                    $result = \gethostname();
-                    break;
-                case 'code':
-                    $result = $response ? $response->getStatusCode() : 'NULL';
-                    break;
-                case 'phrase':
-                    $result = $response ? $response->getReasonPhrase() : 'NULL';
-                    break;
-                case 'error':
-                    $result = $error ? $error->getMessage() : 'NULL';
-                    break;
-                default:
-                    // handle prefixed dynamic headers
-                    if (\strpos($matches[1], 'req_header_') === 0) {
-                        $result = $request->getHeaderLine(\substr($matches[1], 11));
-                    } elseif (\strpos($matches[1], 'res_header_') === 0) {
-                        $result = $response ? $response->getHeaderLine(\substr($matches[1], 11)) : 'NULL';
-                    }
-            }
-            $cache[$matches[1]] = $result;
-            return $result;
-        }, $this->template);
-    }
-    /**
-     * Get headers from message as string
-     */
-    private function headers(MessageInterface $message) : string
-    {
-        $result = '';
-        foreach ($message->getHeaders() as $name => $values) {
-            $result .= $name . ': ' . \implode(', ', $values) . "\r\n";
-        }
-        return \trim($result);
-    }
+	/**
+	 * Apache Common Log Format.
+	 *
+	 * @see https://httpd.apache.org/docs/2.4/logs.html#common
+	 *
+	 * @var string
+	 */
+	public const CLF = '{hostname} {req_header_User-Agent} - [{date_common_log}] "{method} {target} HTTP/{version}" {code} {res_header_Content-Length}';
+	public const DEBUG = ">>>>>>>>\n{request}\n<<<<<<<<\n{response}\n--------\n{error}";
+	public const SHORT = '[{ts}] "{method} {target} HTTP/{version}" {code}';
+	/**
+	 * @var string Template used to format log messages
+	 */
+	private $template;
+	/**
+	 * @param string $template Log message template
+	 */
+	public function __construct(?string $template = self::CLF)
+	{
+		$this->template = $template ?: self::CLF;
+	}
+	/**
+	 * Returns a formatted message string.
+	 *
+	 * @param RequestInterface       $request  Request that was sent
+	 * @param ResponseInterface|null $response Response that was received
+	 * @param \Throwable|null        $error    Exception that was received
+	 */
+	public function format(RequestInterface $request, ?ResponseInterface $response = null, ?\Throwable $error = null) : string
+	{
+		$cache = [];
+		/** @var string */
+		return \preg_replace_callback('/{\\s*([A-Za-z_\\-\\.0-9]+)\\s*}/', function (array $matches) use($request, $response, $error, &$cache) {
+			if (isset($cache[$matches[1]])) {
+				return $cache[$matches[1]];
+			}
+			$result = '';
+			switch ($matches[1]) {
+				case 'request':
+					$result = Psr7\Message::toString($request);
+					break;
+				case 'response':
+					$result = $response ? Psr7\Message::toString($response) : '';
+					break;
+				case 'req_headers':
+					$result = \trim($request->getMethod() . ' ' . $request->getRequestTarget()) . ' HTTP/' . $request->getProtocolVersion() . "\r\n" . $this->headers($request);
+					break;
+				case 'res_headers':
+					$result = $response ? \sprintf('HTTP/%s %d %s', $response->getProtocolVersion(), $response->getStatusCode(), $response->getReasonPhrase()) . "\r\n" . $this->headers($response) : 'NULL';
+					break;
+				case 'req_body':
+					$result = $request->getBody()->__toString();
+					break;
+				case 'res_body':
+					if (!$response instanceof ResponseInterface) {
+						$result = 'NULL';
+						break;
+					}
+					$body = $response->getBody();
+					if (!$body->isSeekable()) {
+						$result = 'RESPONSE_NOT_LOGGEABLE';
+						break;
+					}
+					$result = $response->getBody()->__toString();
+					break;
+				case 'ts':
+				case 'date_iso_8601':
+					$result = \gmdate('c');
+					break;
+				case 'date_common_log':
+					$result = \date('d/M/Y:H:i:s O');
+					break;
+				case 'method':
+					$result = $request->getMethod();
+					break;
+				case 'version':
+					$result = $request->getProtocolVersion();
+					break;
+				case 'uri':
+				case 'url':
+					$result = $request->getUri()->__toString();
+					break;
+				case 'target':
+					$result = $request->getRequestTarget();
+					break;
+				case 'req_version':
+					$result = $request->getProtocolVersion();
+					break;
+				case 'res_version':
+					$result = $response ? $response->getProtocolVersion() : 'NULL';
+					break;
+				case 'host':
+					$result = $request->getHeaderLine('Host');
+					break;
+				case 'hostname':
+					$result = \gethostname();
+					break;
+				case 'code':
+					$result = $response ? $response->getStatusCode() : 'NULL';
+					break;
+				case 'phrase':
+					$result = $response ? $response->getReasonPhrase() : 'NULL';
+					break;
+				case 'error':
+					$result = $error ? $error->getMessage() : 'NULL';
+					break;
+				default:
+					// handle prefixed dynamic headers
+					if (\strpos($matches[1], 'req_header_') === 0) {
+						$result = $request->getHeaderLine(\substr($matches[1], 11));
+					} elseif (\strpos($matches[1], 'res_header_') === 0) {
+						$result = $response ? $response->getHeaderLine(\substr($matches[1], 11)) : 'NULL';
+					}
+			}
+			$cache[$matches[1]] = $result;
+			return $result;
+		}, $this->template);
+	}
+	/**
+	 * Get headers from message as string
+	 */
+	private function headers(MessageInterface $message) : string
+	{
+		$result = '';
+		foreach ($message->getHeaders() as $name => $values) {
+			$result .= $name . ': ' . \implode(', ', $values) . "\r\n";
+		}
+		return \trim($result);
+	}
 }

lib/Vendor/GuzzleHttp/Middleware.php

Indentation +210 added lines, -210 removed lines

@@ -14,214 +14,214 @@
  */
 final class Middleware
 {
-    /**
-     * Middleware that adds cookies to requests.
-     *
-     * The options array must be set to a CookieJarInterface in order to use
-     * cookies. This is typically handled for you by a client.
-     *
-     * @return callable Returns a function that accepts the next handler.
-     */
-    public static function cookies() : callable
-    {
-        return static function (callable $handler) : callable {
-            return static function ($request, array $options) use($handler) {
-                if (empty($options['cookies'])) {
-                    return $handler($request, $options);
-                } elseif (!$options['cookies'] instanceof CookieJarInterface) {
-                    throw new \InvalidArgumentException('OCA\\FullTextSearch_Elasticsearch\\Vendor\\cookies must be an instance of GuzzleHttp\\Cookie\\CookieJarInterface');
-                }
-                $cookieJar = $options['cookies'];
-                $request = $cookieJar->withCookieHeader($request);
-                return $handler($request, $options)->then(static function (ResponseInterface $response) use($cookieJar, $request) : ResponseInterface {
-                    $cookieJar->extractCookies($request, $response);
-                    return $response;
-                });
-            };
-        };
-    }
-    /**
-     * Middleware that throws exceptions for 4xx or 5xx responses when the
-     * "http_errors" request option is set to true.
-     *
-     * @param BodySummarizerInterface|null $bodySummarizer The body summarizer to use in exception messages.
-     *
-     * @return callable(callable): callable Returns a function that accepts the next handler.
-     */
-    public static function httpErrors(?BodySummarizerInterface $bodySummarizer = null) : callable
-    {
-        return static function (callable $handler) use($bodySummarizer) : callable {
-            return static function ($request, array $options) use($handler, $bodySummarizer) {
-                if (empty($options['http_errors'])) {
-                    return $handler($request, $options);
-                }
-                return $handler($request, $options)->then(static function (ResponseInterface $response) use($request, $bodySummarizer) {
-                    $code = $response->getStatusCode();
-                    if ($code < 400) {
-                        return $response;
-                    }
-                    throw RequestException::create($request, $response, null, [], $bodySummarizer);
-                });
-            };
-        };
-    }
-    /**
-     * Middleware that pushes history data to an ArrayAccess container.
-     *
-     * @param array|\ArrayAccess<int, array> $container Container to hold the history (by reference).
-     *
-     * @return callable(callable): callable Returns a function that accepts the next handler.
-     *
-     * @throws \InvalidArgumentException if container is not an array or ArrayAccess.
-     */
-    public static function history(&$container) : callable
-    {
-        if (!\is_array($container) && !$container instanceof \ArrayAccess) {
-            throw new \InvalidArgumentException('history container must be an array or object implementing ArrayAccess');
-        }
-        return static function (callable $handler) use(&$container) : callable {
-            return static function (RequestInterface $request, array $options) use($handler, &$container) {
-                return $handler($request, $options)->then(static function ($value) use($request, &$container, $options) {
-                    $container[] = ['request' => $request, 'response' => $value, 'error' => null, 'options' => $options];
-                    return $value;
-                }, static function ($reason) use($request, &$container, $options) {
-                    $container[] = ['request' => $request, 'response' => null, 'error' => $reason, 'options' => $options];
-                    return P\Create::rejectionFor($reason);
-                });
-            };
-        };
-    }
-    /**
-     * Middleware that invokes a callback before and after sending a request.
-     *
-     * The provided listener cannot modify or alter the response. It simply
-     * "taps" into the chain to be notified before returning the promise. The
-     * before listener accepts a request and options array, and the after
-     * listener accepts a request, options array, and response promise.
-     *
-     * @param callable $before Function to invoke before forwarding the request.
-     * @param callable $after  Function invoked after forwarding.
-     *
-     * @return callable Returns a function that accepts the next handler.
-     */
-    public static function tap(?callable $before = null, ?callable $after = null) : callable
-    {
-        return static function (callable $handler) use($before, $after) : callable {
-            return static function (RequestInterface $request, array $options) use($handler, $before, $after) {
-                if ($before) {
-                    $before($request, $options);
-                }
-                $response = $handler($request, $options);
-                if ($after) {
-                    $after($request, $options, $response);
-                }
-                return $response;
-            };
-        };
-    }
-    /**
-     * Middleware that handles request redirects.
-     *
-     * @return callable Returns a function that accepts the next handler.
-     */
-    public static function redirect() : callable
-    {
-        return static function (callable $handler) : RedirectMiddleware {
-            return new RedirectMiddleware($handler);
-        };
-    }
-    /**
-     * Middleware that retries requests based on the boolean result of
-     * invoking the provided "decider" function.
-     *
-     * If no delay function is provided, a simple implementation of exponential
-     * backoff will be utilized.
-     *
-     * @param callable $decider Function that accepts the number of retries,
-     *                          a request, [response], and [exception] and
-     *                          returns true if the request is to be retried.
-     * @param callable $delay   Function that accepts the number of retries and
-     *                          returns the number of milliseconds to delay.
-     *
-     * @return callable Returns a function that accepts the next handler.
-     */
-    public static function retry(callable $decider, ?callable $delay = null) : callable
-    {
-        return static function (callable $handler) use($decider, $delay) : RetryMiddleware {
-            return new RetryMiddleware($decider, $handler, $delay);
-        };
-    }
-    /**
-     * Middleware that logs requests, responses, and errors using a message
-     * formatter.
-     *
-     * @phpstan-param \Psr\Log\LogLevel::* $logLevel  Level at which to log requests.
-     *
-     * @param LoggerInterface                            $logger    Logs messages.
-     * @param MessageFormatterInterface|MessageFormatter $formatter Formatter used to create message strings.
-     * @param string                                     $logLevel  Level at which to log requests.
-     *
-     * @return callable Returns a function that accepts the next handler.
-     */
-    public static function log(LoggerInterface $logger, $formatter, string $logLevel = 'info') : callable
-    {
-        // To be compatible with Guzzle 7.1.x we need to allow users to pass a MessageFormatter
-        if (!$formatter instanceof MessageFormatter && !$formatter instanceof MessageFormatterInterface) {
-            throw new \LogicException(\sprintf('Argument 2 to %s::log() must be of type %s', self::class, MessageFormatterInterface::class));
-        }
-        return static function (callable $handler) use($logger, $formatter, $logLevel) : callable {
-            return static function (RequestInterface $request, array $options = []) use($handler, $logger, $formatter, $logLevel) {
-                return $handler($request, $options)->then(static function ($response) use($logger, $request, $formatter, $logLevel) : ResponseInterface {
-                    $message = $formatter->format($request, $response);
-                    $logger->log($logLevel, $message);
-                    return $response;
-                }, static function ($reason) use($logger, $request, $formatter) : PromiseInterface {
-                    $response = $reason instanceof RequestException ? $reason->getResponse() : null;
-                    $message = $formatter->format($request, $response, P\Create::exceptionFor($reason));
-                    $logger->error($message);
-                    return P\Create::rejectionFor($reason);
-                });
-            };
-        };
-    }
-    /**
-     * This middleware adds a default content-type if possible, a default
-     * content-length or transfer-encoding header, and the expect header.
-     */
-    public static function prepareBody() : callable
-    {
-        return static function (callable $handler) : PrepareBodyMiddleware {
-            return new PrepareBodyMiddleware($handler);
-        };
-    }
-    /**
-     * Middleware that applies a map function to the request before passing to
-     * the next handler.
-     *
-     * @param callable $fn Function that accepts a RequestInterface and returns
-     *                     a RequestInterface.
-     */
-    public static function mapRequest(callable $fn) : callable
-    {
-        return static function (callable $handler) use($fn) : callable {
-            return static function (RequestInterface $request, array $options) use($handler, $fn) {
-                return $handler($fn($request), $options);
-            };
-        };
-    }
-    /**
-     * Middleware that applies a map function to the resolved promise's
-     * response.
-     *
-     * @param callable $fn Function that accepts a ResponseInterface and
-     *                     returns a ResponseInterface.
-     */
-    public static function mapResponse(callable $fn) : callable
-    {
-        return static function (callable $handler) use($fn) : callable {
-            return static function (RequestInterface $request, array $options) use($handler, $fn) {
-                return $handler($request, $options)->then($fn);
-            };
-        };
-    }
+	/**
+	 * Middleware that adds cookies to requests.
+	 *
+	 * The options array must be set to a CookieJarInterface in order to use
+	 * cookies. This is typically handled for you by a client.
+	 *
+	 * @return callable Returns a function that accepts the next handler.
+	 */
+	public static function cookies() : callable
+	{
+		return static function (callable $handler) : callable {
+			return static function ($request, array $options) use($handler) {
+				if (empty($options['cookies'])) {
+					return $handler($request, $options);
+				} elseif (!$options['cookies'] instanceof CookieJarInterface) {
+					throw new \InvalidArgumentException('OCA\\FullTextSearch_Elasticsearch\\Vendor\\cookies must be an instance of GuzzleHttp\\Cookie\\CookieJarInterface');
+				}
+				$cookieJar = $options['cookies'];
+				$request = $cookieJar->withCookieHeader($request);
+				return $handler($request, $options)->then(static function (ResponseInterface $response) use($cookieJar, $request) : ResponseInterface {
+					$cookieJar->extractCookies($request, $response);
+					return $response;
+				});
+			};
+		};
+	}
+	/**
+	 * Middleware that throws exceptions for 4xx or 5xx responses when the
+	 * "http_errors" request option is set to true.
+	 *
+	 * @param BodySummarizerInterface|null $bodySummarizer The body summarizer to use in exception messages.
+	 *
+	 * @return callable(callable): callable Returns a function that accepts the next handler.
+	 */
+	public static function httpErrors(?BodySummarizerInterface $bodySummarizer = null) : callable
+	{
+		return static function (callable $handler) use($bodySummarizer) : callable {
+			return static function ($request, array $options) use($handler, $bodySummarizer) {
+				if (empty($options['http_errors'])) {
+					return $handler($request, $options);
+				}
+				return $handler($request, $options)->then(static function (ResponseInterface $response) use($request, $bodySummarizer) {
+					$code = $response->getStatusCode();
+					if ($code < 400) {
+						return $response;
+					}
+					throw RequestException::create($request, $response, null, [], $bodySummarizer);
+				});
+			};
+		};
+	}
+	/**
+	 * Middleware that pushes history data to an ArrayAccess container.
+	 *
+	 * @param array|\ArrayAccess<int, array> $container Container to hold the history (by reference).
+	 *
+	 * @return callable(callable): callable Returns a function that accepts the next handler.
+	 *
+	 * @throws \InvalidArgumentException if container is not an array or ArrayAccess.
+	 */
+	public static function history(&$container) : callable
+	{
+		if (!\is_array($container) && !$container instanceof \ArrayAccess) {
+			throw new \InvalidArgumentException('history container must be an array or object implementing ArrayAccess');
+		}
+		return static function (callable $handler) use(&$container) : callable {
+			return static function (RequestInterface $request, array $options) use($handler, &$container) {
+				return $handler($request, $options)->then(static function ($value) use($request, &$container, $options) {
+					$container[] = ['request' => $request, 'response' => $value, 'error' => null, 'options' => $options];
+					return $value;
+				}, static function ($reason) use($request, &$container, $options) {
+					$container[] = ['request' => $request, 'response' => null, 'error' => $reason, 'options' => $options];
+					return P\Create::rejectionFor($reason);
+				});
+			};
+		};
+	}
+	/**
+	 * Middleware that invokes a callback before and after sending a request.
+	 *
+	 * The provided listener cannot modify or alter the response. It simply
+	 * "taps" into the chain to be notified before returning the promise. The
+	 * before listener accepts a request and options array, and the after
+	 * listener accepts a request, options array, and response promise.
+	 *
+	 * @param callable $before Function to invoke before forwarding the request.
+	 * @param callable $after  Function invoked after forwarding.
+	 *
+	 * @return callable Returns a function that accepts the next handler.
+	 */
+	public static function tap(?callable $before = null, ?callable $after = null) : callable
+	{
+		return static function (callable $handler) use($before, $after) : callable {
+			return static function (RequestInterface $request, array $options) use($handler, $before, $after) {
+				if ($before) {
+					$before($request, $options);
+				}
+				$response = $handler($request, $options);
+				if ($after) {
+					$after($request, $options, $response);
+				}
+				return $response;
+			};
+		};
+	}
+	/**
+	 * Middleware that handles request redirects.
+	 *
+	 * @return callable Returns a function that accepts the next handler.
+	 */
+	public static function redirect() : callable
+	{
+		return static function (callable $handler) : RedirectMiddleware {
+			return new RedirectMiddleware($handler);
+		};
+	}
+	/**
+	 * Middleware that retries requests based on the boolean result of
+	 * invoking the provided "decider" function.
+	 *
+	 * If no delay function is provided, a simple implementation of exponential
+	 * backoff will be utilized.
+	 *
+	 * @param callable $decider Function that accepts the number of retries,
+	 *                          a request, [response], and [exception] and
+	 *                          returns true if the request is to be retried.
+	 * @param callable $delay   Function that accepts the number of retries and
+	 *                          returns the number of milliseconds to delay.
+	 *
+	 * @return callable Returns a function that accepts the next handler.
+	 */
+	public static function retry(callable $decider, ?callable $delay = null) : callable
+	{
+		return static function (callable $handler) use($decider, $delay) : RetryMiddleware {
+			return new RetryMiddleware($decider, $handler, $delay);
+		};
+	}
+	/**
+	 * Middleware that logs requests, responses, and errors using a message
+	 * formatter.
+	 *
+	 * @phpstan-param \Psr\Log\LogLevel::* $logLevel  Level at which to log requests.
+	 *
+	 * @param LoggerInterface                            $logger    Logs messages.
+	 * @param MessageFormatterInterface|MessageFormatter $formatter Formatter used to create message strings.
+	 * @param string                                     $logLevel  Level at which to log requests.
+	 *
+	 * @return callable Returns a function that accepts the next handler.
+	 */
+	public static function log(LoggerInterface $logger, $formatter, string $logLevel = 'info') : callable
+	{
+		// To be compatible with Guzzle 7.1.x we need to allow users to pass a MessageFormatter
+		if (!$formatter instanceof MessageFormatter && !$formatter instanceof MessageFormatterInterface) {
+			throw new \LogicException(\sprintf('Argument 2 to %s::log() must be of type %s', self::class, MessageFormatterInterface::class));
+		}
+		return static function (callable $handler) use($logger, $formatter, $logLevel) : callable {
+			return static function (RequestInterface $request, array $options = []) use($handler, $logger, $formatter, $logLevel) {
+				return $handler($request, $options)->then(static function ($response) use($logger, $request, $formatter, $logLevel) : ResponseInterface {
+					$message = $formatter->format($request, $response);
+					$logger->log($logLevel, $message);
+					return $response;
+				}, static function ($reason) use($logger, $request, $formatter) : PromiseInterface {
+					$response = $reason instanceof RequestException ? $reason->getResponse() : null;
+					$message = $formatter->format($request, $response, P\Create::exceptionFor($reason));
+					$logger->error($message);
+					return P\Create::rejectionFor($reason);
+				});
+			};
+		};
+	}
+	/**
+	 * This middleware adds a default content-type if possible, a default
+	 * content-length or transfer-encoding header, and the expect header.
+	 */
+	public static function prepareBody() : callable
+	{
+		return static function (callable $handler) : PrepareBodyMiddleware {
+			return new PrepareBodyMiddleware($handler);
+		};
+	}
+	/**
+	 * Middleware that applies a map function to the request before passing to
+	 * the next handler.
+	 *
+	 * @param callable $fn Function that accepts a RequestInterface and returns
+	 *                     a RequestInterface.
+	 */
+	public static function mapRequest(callable $fn) : callable
+	{
+		return static function (callable $handler) use($fn) : callable {
+			return static function (RequestInterface $request, array $options) use($handler, $fn) {
+				return $handler($fn($request), $options);
+			};
+		};
+	}
+	/**
+	 * Middleware that applies a map function to the resolved promise's
+	 * response.
+	 *
+	 * @param callable $fn Function that accepts a ResponseInterface and
+	 *                     returns a ResponseInterface.
+	 */
+	public static function mapResponse(callable $fn) : callable
+	{
+		return static function (callable $handler) use($fn) : callable {
+			return static function (RequestInterface $request, array $options) use($handler, $fn) {
+				return $handler($request, $options)->then($fn);
+			};
+		};
+	}
 }

Spacing +23 added lines, -23 removed lines

@@ -24,8 +24,8 @@ 
      */
     public static function cookies() : callable
     {
-        return static function (callable $handler) : callable {
-            return static function ($request, array $options) use($handler) {
+        return static function(callable $handler) : callable {
+            return static function($request, array $options) use($handler) {
                 if (empty($options['cookies'])) {
                     return $handler($request, $options);
                 } elseif (!$options['cookies'] instanceof CookieJarInterface) {
@@ -33,7 +33,7 @@ 
                 }
                 $cookieJar = $options['cookies'];
                 $request = $cookieJar->withCookieHeader($request);
-                return $handler($request, $options)->then(static function (ResponseInterface $response) use($cookieJar, $request) : ResponseInterface {
+                return $handler($request, $options)->then(static function(ResponseInterface $response) use($cookieJar, $request) : ResponseInterface {
                     $cookieJar->extractCookies($request, $response);
                     return $response;
                 });
@@ -50,12 +50,12 @@ 
      */
     public static function httpErrors(?BodySummarizerInterface $bodySummarizer = null) : callable
     {
-        return static function (callable $handler) use($bodySummarizer) : callable {
-            return static function ($request, array $options) use($handler, $bodySummarizer) {
+        return static function(callable $handler) use($bodySummarizer) : callable {
+            return static function($request, array $options) use($handler, $bodySummarizer) {
                 if (empty($options['http_errors'])) {
                     return $handler($request, $options);
                 }
-                return $handler($request, $options)->then(static function (ResponseInterface $response) use($request, $bodySummarizer) {
+                return $handler($request, $options)->then(static function(ResponseInterface $response) use($request, $bodySummarizer) {
                     $code = $response->getStatusCode();
                     if ($code < 400) {
                         return $response;
@@ -79,12 +79,12 @@ 
         if (!\is_array($container) && !$container instanceof \ArrayAccess) {
             throw new \InvalidArgumentException('history container must be an array or object implementing ArrayAccess');
         }
-        return static function (callable $handler) use(&$container) : callable {
-            return static function (RequestInterface $request, array $options) use($handler, &$container) {
-                return $handler($request, $options)->then(static function ($value) use($request, &$container, $options) {
+        return static function(callable $handler) use(&$container) : callable {
+            return static function(RequestInterface $request, array $options) use($handler, &$container) {
+                return $handler($request, $options)->then(static function($value) use($request, &$container, $options) {
                     $container[] = ['request' => $request, 'response' => $value, 'error' => null, 'options' => $options];
                     return $value;
-                }, static function ($reason) use($request, &$container, $options) {
+                }, static function($reason) use($request, &$container, $options) {
                     $container[] = ['request' => $request, 'response' => null, 'error' => $reason, 'options' => $options];
                     return P\Create::rejectionFor($reason);
                 });
@@ -106,8 +106,8 @@ 
      */
     public static function tap(?callable $before = null, ?callable $after = null) : callable
     {
-        return static function (callable $handler) use($before, $after) : callable {
-            return static function (RequestInterface $request, array $options) use($handler, $before, $after) {
+        return static function(callable $handler) use($before, $after) : callable {
+            return static function(RequestInterface $request, array $options) use($handler, $before, $after) {
                 if ($before) {
                     $before($request, $options);
                 }
@@ -126,7 +126,7 @@ 
      */
     public static function redirect() : callable
     {
-        return static function (callable $handler) : RedirectMiddleware {
+        return static function(callable $handler) : RedirectMiddleware {
             return new RedirectMiddleware($handler);
         };
     }
@@ -147,7 +147,7 @@ 
      */
     public static function retry(callable $decider, ?callable $delay = null) : callable
     {
-        return static function (callable $handler) use($decider, $delay) : RetryMiddleware {
+        return static function(callable $handler) use($decider, $delay) : RetryMiddleware {
             return new RetryMiddleware($decider, $handler, $delay);
         };
     }
@@ -169,13 +169,13 @@ 
         if (!$formatter instanceof MessageFormatter && !$formatter instanceof MessageFormatterInterface) {
             throw new \LogicException(\sprintf('Argument 2 to %s::log() must be of type %s', self::class, MessageFormatterInterface::class));
         }
-        return static function (callable $handler) use($logger, $formatter, $logLevel) : callable {
-            return static function (RequestInterface $request, array $options = []) use($handler, $logger, $formatter, $logLevel) {
-                return $handler($request, $options)->then(static function ($response) use($logger, $request, $formatter, $logLevel) : ResponseInterface {
+        return static function(callable $handler) use($logger, $formatter, $logLevel) : callable {
+            return static function(RequestInterface $request, array $options = []) use($handler, $logger, $formatter, $logLevel) {
+                return $handler($request, $options)->then(static function($response) use($logger, $request, $formatter, $logLevel) : ResponseInterface {
                     $message = $formatter->format($request, $response);
                     $logger->log($logLevel, $message);
                     return $response;
-                }, static function ($reason) use($logger, $request, $formatter) : PromiseInterface {
+                }, static function($reason) use($logger, $request, $formatter) : PromiseInterface {
                     $response = $reason instanceof RequestException ? $reason->getResponse() : null;
                     $message = $formatter->format($request, $response, P\Create::exceptionFor($reason));
                     $logger->error($message);
@@ -190,7 +190,7 @@ 
      */
     public static function prepareBody() : callable
     {
-        return static function (callable $handler) : PrepareBodyMiddleware {
+        return static function(callable $handler) : PrepareBodyMiddleware {
             return new PrepareBodyMiddleware($handler);
         };
     }
@@ -203,8 +203,8 @@ 
      */
     public static function mapRequest(callable $fn) : callable
     {
-        return static function (callable $handler) use($fn) : callable {
-            return static function (RequestInterface $request, array $options) use($handler, $fn) {
+        return static function(callable $handler) use($fn) : callable {
+            return static function(RequestInterface $request, array $options) use($handler, $fn) {
                 return $handler($fn($request), $options);
             };
         };
@@ -218,8 +218,8 @@ 
      */
     public static function mapResponse(callable $fn) : callable
     {
-        return static function (callable $handler) use($fn) : callable {
-            return static function (RequestInterface $request, array $options) use($handler, $fn) {
+        return static function(callable $handler) use($fn) : callable {
+            return static function(RequestInterface $request, array $options) use($handler, $fn) {
                 return $handler($request, $options)->then($fn);
             };
         };

lib/Vendor/GuzzleHttp/Handler/StreamHandler.php

Indentation +435 added lines, -435 removed lines

@@ -21,439 +21,439 @@
  */
 class StreamHandler
 {
-    /**
-     * @var array
-     */
-    private $lastHeaders = [];
-    /**
-     * Sends an HTTP request.
-     *
-     * @param RequestInterface $request Request to send.
-     * @param array            $options Request transfer options.
-     */
-    public function __invoke(RequestInterface $request, array $options) : PromiseInterface
-    {
-        // Sleep if there is a delay specified.
-        if (isset($options['delay'])) {
-            \usleep($options['delay'] * 1000);
-        }
-        $protocolVersion = $request->getProtocolVersion();
-        if ('1.0' !== $protocolVersion && '1.1' !== $protocolVersion) {
-            throw new ConnectException(\sprintf('HTTP/%s is not supported by the stream handler.', $protocolVersion), $request);
-        }
-        $startTime = isset($options['on_stats']) ? Utils::currentTime() : null;
-        try {
-            // Does not support the expect header.
-            $request = $request->withoutHeader('Expect');
-            // Append a content-length header if body size is zero to match
-            // cURL's behavior.
-            if (0 === $request->getBody()->getSize()) {
-                $request = $request->withHeader('Content-Length', '0');
-            }
-            return $this->createResponse($request, $options, $this->createStream($request, $options), $startTime);
-        } catch (\InvalidArgumentException $e) {
-            throw $e;
-        } catch (\Exception $e) {
-            // Determine if the error was a networking error.
-            $message = $e->getMessage();
-            // This list can probably get more comprehensive.
-            if (\false !== \strpos($message, 'getaddrinfo') || \false !== \strpos($message, 'Connection refused') || \false !== \strpos($message, "couldn't connect to host") || \false !== \strpos($message, 'connection attempt failed')) {
-                $e = new ConnectException($e->getMessage(), $request, $e);
-            } else {
-                $e = RequestException::wrapException($request, $e);
-            }
-            $this->invokeStats($options, $request, $startTime, null, $e);
-            return P\Create::rejectionFor($e);
-        }
-    }
-    private function invokeStats(array $options, RequestInterface $request, ?float $startTime, ?ResponseInterface $response = null, ?\Throwable $error = null) : void
-    {
-        if (isset($options['on_stats'])) {
-            $stats = new TransferStats($request, $response, Utils::currentTime() - $startTime, $error, []);
-            $options['on_stats']($stats);
-        }
-    }
-    /**
-     * @param resource $stream
-     */
-    private function createResponse(RequestInterface $request, array $options, $stream, ?float $startTime) : PromiseInterface
-    {
-        $hdrs = $this->lastHeaders;
-        $this->lastHeaders = [];
-        try {
-            [$ver, $status, $reason, $headers] = HeaderProcessor::parseHeaders($hdrs);
-        } catch (\Exception $e) {
-            return P\Create::rejectionFor(new RequestException('An error was encountered while creating the response', $request, null, $e));
-        }
-        [$stream, $headers] = $this->checkDecode($options, $headers, $stream);
-        $stream = Psr7\Utils::streamFor($stream);
-        $sink = $stream;
-        if (\strcasecmp('HEAD', $request->getMethod())) {
-            $sink = $this->createSink($stream, $options);
-        }
-        try {
-            $response = new Psr7\Response($status, $headers, $sink, $ver, $reason);
-        } catch (\Exception $e) {
-            return P\Create::rejectionFor(new RequestException('An error was encountered while creating the response', $request, null, $e));
-        }
-        if (isset($options['on_headers'])) {
-            try {
-                $options['on_headers']($response);
-            } catch (\Exception $e) {
-                return P\Create::rejectionFor(new RequestException('An error was encountered during the on_headers event', $request, $response, $e));
-            }
-        }
-        // Do not drain when the request is a HEAD request because they have
-        // no body.
-        if ($sink !== $stream) {
-            $this->drain($stream, $sink, $response->getHeaderLine('Content-Length'));
-        }
-        $this->invokeStats($options, $request, $startTime, $response, null);
-        return new FulfilledPromise($response);
-    }
-    private function createSink(StreamInterface $stream, array $options) : StreamInterface
-    {
-        if (!empty($options['stream'])) {
-            return $stream;
-        }
-        $sink = $options['sink'] ?? Psr7\Utils::tryFopen('php://temp', 'r+');
-        return \is_string($sink) ? new Psr7\LazyOpenStream($sink, 'w+') : Psr7\Utils::streamFor($sink);
-    }
-    /**
-     * @param resource $stream
-     */
-    private function checkDecode(array $options, array $headers, $stream) : array
-    {
-        // Automatically decode responses when instructed.
-        if (!empty($options['decode_content'])) {
-            $normalizedKeys = Utils::normalizeHeaderKeys($headers);
-            if (isset($normalizedKeys['content-encoding'])) {
-                $encoding = $headers[$normalizedKeys['content-encoding']];
-                if ($encoding[0] === 'gzip' || $encoding[0] === 'deflate') {
-                    $stream = new Psr7\InflateStream(Psr7\Utils::streamFor($stream));
-                    $headers['x-encoded-content-encoding'] = $headers[$normalizedKeys['content-encoding']];
-                    // Remove content-encoding header
-                    unset($headers[$normalizedKeys['content-encoding']]);
-                    // Fix content-length header
-                    if (isset($normalizedKeys['content-length'])) {
-                        $headers['x-encoded-content-length'] = $headers[$normalizedKeys['content-length']];
-                        $length = (int) $stream->getSize();
-                        if ($length === 0) {
-                            unset($headers[$normalizedKeys['content-length']]);
-                        } else {
-                            $headers[$normalizedKeys['content-length']] = [$length];
-                        }
-                    }
-                }
-            }
-        }
-        return [$stream, $headers];
-    }
-    /**
-     * Drains the source stream into the "sink" client option.
-     *
-     * @param string $contentLength Header specifying the amount of
-     *                              data to read.
-     *
-     * @throws \RuntimeException when the sink option is invalid.
-     */
-    private function drain(StreamInterface $source, StreamInterface $sink, string $contentLength) : StreamInterface
-    {
-        // If a content-length header is provided, then stop reading once
-        // that number of bytes has been read. This can prevent infinitely
-        // reading from a stream when dealing with servers that do not honor
-        // Connection: Close headers.
-        Psr7\Utils::copyToStream($source, $sink, \strlen($contentLength) > 0 && (int) $contentLength > 0 ? (int) $contentLength : -1);
-        $sink->seek(0);
-        $source->close();
-        return $sink;
-    }
-    /**
-     * Create a resource and check to ensure it was created successfully
-     *
-     * @param callable $callback Callable that returns stream resource
-     *
-     * @return resource
-     *
-     * @throws \RuntimeException on error
-     */
-    private function createResource(callable $callback)
-    {
-        $errors = [];
-        \set_error_handler(static function ($_, $msg, $file, $line) use(&$errors) : bool {
-            $errors[] = ['message' => $msg, 'file' => $file, 'line' => $line];
-            return \true;
-        });
-        try {
-            $resource = $callback();
-        } finally {
-            \restore_error_handler();
-        }
-        if (!$resource) {
-            $message = 'Error creating resource: ';
-            foreach ($errors as $err) {
-                foreach ($err as $key => $value) {
-                    $message .= "[{$key}] {$value}" . \PHP_EOL;
-                }
-            }
-            throw new \RuntimeException(\trim($message));
-        }
-        return $resource;
-    }
-    /**
-     * @return resource
-     */
-    private function createStream(RequestInterface $request, array $options)
-    {
-        static $methods;
-        if (!$methods) {
-            $methods = \array_flip(\get_class_methods(__CLASS__));
-        }
-        if (!\in_array($request->getUri()->getScheme(), ['http', 'https'])) {
-            throw new RequestException(\sprintf("The scheme '%s' is not supported.", $request->getUri()->getScheme()), $request);
-        }
-        // HTTP/1.1 streams using the PHP stream wrapper require a
-        // Connection: close header
-        if ($request->getProtocolVersion() === '1.1' && !$request->hasHeader('Connection')) {
-            $request = $request->withHeader('Connection', 'close');
-        }
-        // Ensure SSL is verified by default
-        if (!isset($options['verify'])) {
-            $options['verify'] = \true;
-        }
-        $params = [];
-        $context = $this->getDefaultContext($request);
-        if (isset($options['on_headers']) && !\is_callable($options['on_headers'])) {
-            throw new \InvalidArgumentException('on_headers must be callable');
-        }
-        if (!empty($options)) {
-            foreach ($options as $key => $value) {
-                $method = "add_{$key}";
-                if (isset($methods[$method])) {
-                    $this->{$method}($request, $context, $value, $params);
-                }
-            }
-        }
-        if (isset($options['stream_context'])) {
-            if (!\is_array($options['stream_context'])) {
-                throw new \InvalidArgumentException('stream_context must be an array');
-            }
-            $context = \array_replace_recursive($context, $options['stream_context']);
-        }
-        // Microsoft NTLM authentication only supported with curl handler
-        if (isset($options['auth'][2]) && 'ntlm' === $options['auth'][2]) {
-            throw new \InvalidArgumentException('Microsoft NTLM authentication only supported with curl handler');
-        }
-        $uri = $this->resolveHost($request, $options);
-        $contextResource = $this->createResource(static function () use($context, $params) {
-            return \stream_context_create($context, $params);
-        });
-        return $this->createResource(function () use($uri, &$http_response_header, $contextResource, $context, $options, $request) {
-            $resource = @\fopen((string) $uri, 'r', \false, $contextResource);
-            $this->lastHeaders = $http_response_header ?? [];
-            if (\false === $resource) {
-                throw new ConnectException(\sprintf('Connection refused for URI %s', $uri), $request, null, $context);
-            }
-            if (isset($options['read_timeout'])) {
-                $readTimeout = $options['read_timeout'];
-                $sec = (int) $readTimeout;
-                $usec = ($readTimeout - $sec) * 100000;
-                \stream_set_timeout($resource, $sec, $usec);
-            }
-            return $resource;
-        });
-    }
-    private function resolveHost(RequestInterface $request, array $options) : UriInterface
-    {
-        $uri = $request->getUri();
-        if (isset($options['force_ip_resolve']) && !\filter_var($uri->getHost(), \FILTER_VALIDATE_IP)) {
-            if ('v4' === $options['force_ip_resolve']) {
-                $records = \dns_get_record($uri->getHost(), \DNS_A);
-                if (\false === $records || !isset($records[0]['ip'])) {
-                    throw new ConnectException(\sprintf("Could not resolve IPv4 address for host '%s'", $uri->getHost()), $request);
-                }
-                return $uri->withHost($records[0]['ip']);
-            }
-            if ('v6' === $options['force_ip_resolve']) {
-                $records = \dns_get_record($uri->getHost(), \DNS_AAAA);
-                if (\false === $records || !isset($records[0]['ipv6'])) {
-                    throw new ConnectException(\sprintf("Could not resolve IPv6 address for host '%s'", $uri->getHost()), $request);
-                }
-                return $uri->withHost('[' . $records[0]['ipv6'] . ']');
-            }
-        }
-        return $uri;
-    }
-    private function getDefaultContext(RequestInterface $request) : array
-    {
-        $headers = '';
-        foreach ($request->getHeaders() as $name => $value) {
-            foreach ($value as $val) {
-                $headers .= "{$name}: {$val}\r\n";
-            }
-        }
-        $context = ['http' => ['method' => $request->getMethod(), 'header' => $headers, 'protocol_version' => $request->getProtocolVersion(), 'ignore_errors' => \true, 'follow_location' => 0], 'ssl' => ['peer_name' => $request->getUri()->getHost()]];
-        $body = (string) $request->getBody();
-        if ('' !== $body) {
-            $context['http']['content'] = $body;
-            // Prevent the HTTP handler from adding a Content-Type header.
-            if (!$request->hasHeader('Content-Type')) {
-                $context['http']['header'] .= "Content-Type:\r\n";
-            }
-        }
-        $context['http']['header'] = \rtrim($context['http']['header']);
-        return $context;
-    }
-    /**
-     * @param mixed $value as passed via Request transfer options.
-     */
-    private function add_proxy(RequestInterface $request, array &$options, $value, array &$params) : void
-    {
-        $uri = null;
-        if (!\is_array($value)) {
-            $uri = $value;
-        } else {
-            $scheme = $request->getUri()->getScheme();
-            if (isset($value[$scheme])) {
-                if (!isset($value['no']) || !Utils::isHostInNoProxy($request->getUri()->getHost(), $value['no'])) {
-                    $uri = $value[$scheme];
-                }
-            }
-        }
-        if (!$uri) {
-            return;
-        }
-        $parsed = $this->parse_proxy($uri);
-        $options['http']['proxy'] = $parsed['proxy'];
-        if ($parsed['auth']) {
-            if (!isset($options['http']['header'])) {
-                $options['http']['header'] = [];
-            }
-            $options['http']['header'] .= "\r\nProxy-Authorization: {$parsed['auth']}";
-        }
-    }
-    /**
-     * Parses the given proxy URL to make it compatible with the format PHP's stream context expects.
-     */
-    private function parse_proxy(string $url) : array
-    {
-        $parsed = \parse_url($url);
-        if ($parsed !== \false && isset($parsed['scheme']) && $parsed['scheme'] === 'http') {
-            if (isset($parsed['host']) && isset($parsed['port'])) {
-                $auth = null;
-                if (isset($parsed['user']) && isset($parsed['pass'])) {
-                    $auth = \base64_encode("{$parsed['user']}:{$parsed['pass']}");
-                }
-                return ['proxy' => "tcp://{$parsed['host']}:{$parsed['port']}", 'auth' => $auth ? "Basic {$auth}" : null];
-            }
-        }
-        // Return proxy as-is.
-        return ['proxy' => $url, 'auth' => null];
-    }
-    /**
-     * @param mixed $value as passed via Request transfer options.
-     */
-    private function add_timeout(RequestInterface $request, array &$options, $value, array &$params) : void
-    {
-        if ($value > 0) {
-            $options['http']['timeout'] = $value;
-        }
-    }
-    /**
-     * @param mixed $value as passed via Request transfer options.
-     */
-    private function add_crypto_method(RequestInterface $request, array &$options, $value, array &$params) : void
-    {
-        if ($value === \STREAM_CRYPTO_METHOD_TLSv1_0_CLIENT || $value === \STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT || $value === \STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT || \defined('STREAM_CRYPTO_METHOD_TLSv1_3_CLIENT') && $value === \STREAM_CRYPTO_METHOD_TLSv1_3_CLIENT) {
-            $options['http']['crypto_method'] = $value;
-            return;
-        }
-        throw new \InvalidArgumentException('Invalid crypto_method request option: unknown version provided');
-    }
-    /**
-     * @param mixed $value as passed via Request transfer options.
-     */
-    private function add_verify(RequestInterface $request, array &$options, $value, array &$params) : void
-    {
-        if ($value === \false) {
-            $options['ssl']['verify_peer'] = \false;
-            $options['ssl']['verify_peer_name'] = \false;
-            return;
-        }
-        if (\is_string($value)) {
-            $options['ssl']['cafile'] = $value;
-            if (!\file_exists($value)) {
-                throw new \RuntimeException("SSL CA bundle not found: {$value}");
-            }
-        } elseif ($value !== \true) {
-            throw new \InvalidArgumentException('Invalid verify request option');
-        }
-        $options['ssl']['verify_peer'] = \true;
-        $options['ssl']['verify_peer_name'] = \true;
-        $options['ssl']['allow_self_signed'] = \false;
-    }
-    /**
-     * @param mixed $value as passed via Request transfer options.
-     */
-    private function add_cert(RequestInterface $request, array &$options, $value, array &$params) : void
-    {
-        if (\is_array($value)) {
-            $options['ssl']['passphrase'] = $value[1];
-            $value = $value[0];
-        }
-        if (!\file_exists($value)) {
-            throw new \RuntimeException("SSL certificate not found: {$value}");
-        }
-        $options['ssl']['local_cert'] = $value;
-    }
-    /**
-     * @param mixed $value as passed via Request transfer options.
-     */
-    private function add_progress(RequestInterface $request, array &$options, $value, array &$params) : void
-    {
-        self::addNotification($params, static function ($code, $a, $b, $c, $transferred, $total) use($value) {
-            if ($code == \STREAM_NOTIFY_PROGRESS) {
-                // The upload progress cannot be determined. Use 0 for cURL compatibility:
-                // https://curl.se/libcurl/c/CURLOPT_PROGRESSFUNCTION.html
-                $value($total, $transferred, 0, 0);
-            }
-        });
-    }
-    /**
-     * @param mixed $value as passed via Request transfer options.
-     */
-    private function add_debug(RequestInterface $request, array &$options, $value, array &$params) : void
-    {
-        if ($value === \false) {
-            return;
-        }
-        static $map = [\STREAM_NOTIFY_CONNECT => 'CONNECT', \STREAM_NOTIFY_AUTH_REQUIRED => 'AUTH_REQUIRED', \STREAM_NOTIFY_AUTH_RESULT => 'AUTH_RESULT', \STREAM_NOTIFY_MIME_TYPE_IS => 'MIME_TYPE_IS', \STREAM_NOTIFY_FILE_SIZE_IS => 'FILE_SIZE_IS', \STREAM_NOTIFY_REDIRECTED => 'REDIRECTED', \STREAM_NOTIFY_PROGRESS => 'PROGRESS', \STREAM_NOTIFY_FAILURE => 'FAILURE', \STREAM_NOTIFY_COMPLETED => 'COMPLETED', \STREAM_NOTIFY_RESOLVE => 'RESOLVE'];
-        static $args = ['severity', 'message', 'message_code', 'bytes_transferred', 'bytes_max'];
-        $value = Utils::debugResource($value);
-        $ident = $request->getMethod() . ' ' . $request->getUri()->withFragment('');
-        self::addNotification($params, static function (int $code, ...$passed) use($ident, $value, $map, $args) : void {
-            \fprintf($value, '<%s> [%s] ', $ident, $map[$code]);
-            foreach (\array_filter($passed) as $i => $v) {
-                \fwrite($value, $args[$i] . ': "' . $v . '" ');
-            }
-            \fwrite($value, "\n");
-        });
-    }
-    private static function addNotification(array &$params, callable $notify) : void
-    {
-        // Wrap the existing function if needed.
-        if (!isset($params['notification'])) {
-            $params['notification'] = $notify;
-        } else {
-            $params['notification'] = self::callArray([$params['notification'], $notify]);
-        }
-    }
-    private static function callArray(array $functions) : callable
-    {
-        return static function (...$args) use($functions) {
-            foreach ($functions as $fn) {
-                $fn(...$args);
-            }
-        };
-    }
+	/**
+	 * @var array
+	 */
+	private $lastHeaders = [];
+	/**
+	 * Sends an HTTP request.
+	 *
+	 * @param RequestInterface $request Request to send.
+	 * @param array            $options Request transfer options.
+	 */
+	public function __invoke(RequestInterface $request, array $options) : PromiseInterface
+	{
+		// Sleep if there is a delay specified.
+		if (isset($options['delay'])) {
+			\usleep($options['delay'] * 1000);
+		}
+		$protocolVersion = $request->getProtocolVersion();
+		if ('1.0' !== $protocolVersion && '1.1' !== $protocolVersion) {
+			throw new ConnectException(\sprintf('HTTP/%s is not supported by the stream handler.', $protocolVersion), $request);
+		}
+		$startTime = isset($options['on_stats']) ? Utils::currentTime() : null;
+		try {
+			// Does not support the expect header.
+			$request = $request->withoutHeader('Expect');
+			// Append a content-length header if body size is zero to match
+			// cURL's behavior.
+			if (0 === $request->getBody()->getSize()) {
+				$request = $request->withHeader('Content-Length', '0');
+			}
+			return $this->createResponse($request, $options, $this->createStream($request, $options), $startTime);
+		} catch (\InvalidArgumentException $e) {
+			throw $e;
+		} catch (\Exception $e) {
+			// Determine if the error was a networking error.
+			$message = $e->getMessage();
+			// This list can probably get more comprehensive.
+			if (\false !== \strpos($message, 'getaddrinfo') || \false !== \strpos($message, 'Connection refused') || \false !== \strpos($message, "couldn't connect to host") || \false !== \strpos($message, 'connection attempt failed')) {
+				$e = new ConnectException($e->getMessage(), $request, $e);
+			} else {
+				$e = RequestException::wrapException($request, $e);
+			}
+			$this->invokeStats($options, $request, $startTime, null, $e);
+			return P\Create::rejectionFor($e);
+		}
+	}
+	private function invokeStats(array $options, RequestInterface $request, ?float $startTime, ?ResponseInterface $response = null, ?\Throwable $error = null) : void
+	{
+		if (isset($options['on_stats'])) {
+			$stats = new TransferStats($request, $response, Utils::currentTime() - $startTime, $error, []);
+			$options['on_stats']($stats);
+		}
+	}
+	/**
+	 * @param resource $stream
+	 */
+	private function createResponse(RequestInterface $request, array $options, $stream, ?float $startTime) : PromiseInterface
+	{
+		$hdrs = $this->lastHeaders;
+		$this->lastHeaders = [];
+		try {
+			[$ver, $status, $reason, $headers] = HeaderProcessor::parseHeaders($hdrs);
+		} catch (\Exception $e) {
+			return P\Create::rejectionFor(new RequestException('An error was encountered while creating the response', $request, null, $e));
+		}
+		[$stream, $headers] = $this->checkDecode($options, $headers, $stream);
+		$stream = Psr7\Utils::streamFor($stream);
+		$sink = $stream;
+		if (\strcasecmp('HEAD', $request->getMethod())) {
+			$sink = $this->createSink($stream, $options);
+		}
+		try {
+			$response = new Psr7\Response($status, $headers, $sink, $ver, $reason);
+		} catch (\Exception $e) {
+			return P\Create::rejectionFor(new RequestException('An error was encountered while creating the response', $request, null, $e));
+		}
+		if (isset($options['on_headers'])) {
+			try {
+				$options['on_headers']($response);
+			} catch (\Exception $e) {
+				return P\Create::rejectionFor(new RequestException('An error was encountered during the on_headers event', $request, $response, $e));
+			}
+		}
+		// Do not drain when the request is a HEAD request because they have
+		// no body.
+		if ($sink !== $stream) {
+			$this->drain($stream, $sink, $response->getHeaderLine('Content-Length'));
+		}
+		$this->invokeStats($options, $request, $startTime, $response, null);
+		return new FulfilledPromise($response);
+	}
+	private function createSink(StreamInterface $stream, array $options) : StreamInterface
+	{
+		if (!empty($options['stream'])) {
+			return $stream;
+		}
+		$sink = $options['sink'] ?? Psr7\Utils::tryFopen('php://temp', 'r+');
+		return \is_string($sink) ? new Psr7\LazyOpenStream($sink, 'w+') : Psr7\Utils::streamFor($sink);
+	}
+	/**
+	 * @param resource $stream
+	 */
+	private function checkDecode(array $options, array $headers, $stream) : array
+	{
+		// Automatically decode responses when instructed.
+		if (!empty($options['decode_content'])) {
+			$normalizedKeys = Utils::normalizeHeaderKeys($headers);
+			if (isset($normalizedKeys['content-encoding'])) {
+				$encoding = $headers[$normalizedKeys['content-encoding']];
+				if ($encoding[0] === 'gzip' || $encoding[0] === 'deflate') {
+					$stream = new Psr7\InflateStream(Psr7\Utils::streamFor($stream));
+					$headers['x-encoded-content-encoding'] = $headers[$normalizedKeys['content-encoding']];
+					// Remove content-encoding header
+					unset($headers[$normalizedKeys['content-encoding']]);
+					// Fix content-length header
+					if (isset($normalizedKeys['content-length'])) {
+						$headers['x-encoded-content-length'] = $headers[$normalizedKeys['content-length']];
+						$length = (int) $stream->getSize();
+						if ($length === 0) {
+							unset($headers[$normalizedKeys['content-length']]);
+						} else {
+							$headers[$normalizedKeys['content-length']] = [$length];
+						}
+					}
+				}
+			}
+		}
+		return [$stream, $headers];
+	}
+	/**
+	 * Drains the source stream into the "sink" client option.
+	 *
+	 * @param string $contentLength Header specifying the amount of
+	 *                              data to read.
+	 *
+	 * @throws \RuntimeException when the sink option is invalid.
+	 */
+	private function drain(StreamInterface $source, StreamInterface $sink, string $contentLength) : StreamInterface
+	{
+		// If a content-length header is provided, then stop reading once
+		// that number of bytes has been read. This can prevent infinitely
+		// reading from a stream when dealing with servers that do not honor
+		// Connection: Close headers.
+		Psr7\Utils::copyToStream($source, $sink, \strlen($contentLength) > 0 && (int) $contentLength > 0 ? (int) $contentLength : -1);
+		$sink->seek(0);
+		$source->close();
+		return $sink;
+	}
+	/**
+	 * Create a resource and check to ensure it was created successfully
+	 *
+	 * @param callable $callback Callable that returns stream resource
+	 *
+	 * @return resource
+	 *
+	 * @throws \RuntimeException on error
+	 */
+	private function createResource(callable $callback)
+	{
+		$errors = [];
+		\set_error_handler(static function ($_, $msg, $file, $line) use(&$errors) : bool {
+			$errors[] = ['message' => $msg, 'file' => $file, 'line' => $line];
+			return \true;
+		});
+		try {
+			$resource = $callback();
+		} finally {
+			\restore_error_handler();
+		}
+		if (!$resource) {
+			$message = 'Error creating resource: ';
+			foreach ($errors as $err) {
+				foreach ($err as $key => $value) {
+					$message .= "[{$key}] {$value}" . \PHP_EOL;
+				}
+			}
+			throw new \RuntimeException(\trim($message));
+		}
+		return $resource;
+	}
+	/**
+	 * @return resource
+	 */
+	private function createStream(RequestInterface $request, array $options)
+	{
+		static $methods;
+		if (!$methods) {
+			$methods = \array_flip(\get_class_methods(__CLASS__));
+		}
+		if (!\in_array($request->getUri()->getScheme(), ['http', 'https'])) {
+			throw new RequestException(\sprintf("The scheme '%s' is not supported.", $request->getUri()->getScheme()), $request);
+		}
+		// HTTP/1.1 streams using the PHP stream wrapper require a
+		// Connection: close header
+		if ($request->getProtocolVersion() === '1.1' && !$request->hasHeader('Connection')) {
+			$request = $request->withHeader('Connection', 'close');
+		}
+		// Ensure SSL is verified by default
+		if (!isset($options['verify'])) {
+			$options['verify'] = \true;
+		}
+		$params = [];
+		$context = $this->getDefaultContext($request);
+		if (isset($options['on_headers']) && !\is_callable($options['on_headers'])) {
+			throw new \InvalidArgumentException('on_headers must be callable');
+		}
+		if (!empty($options)) {
+			foreach ($options as $key => $value) {
+				$method = "add_{$key}";
+				if (isset($methods[$method])) {
+					$this->{$method}($request, $context, $value, $params);
+				}
+			}
+		}
+		if (isset($options['stream_context'])) {
+			if (!\is_array($options['stream_context'])) {
+				throw new \InvalidArgumentException('stream_context must be an array');
+			}
+			$context = \array_replace_recursive($context, $options['stream_context']);
+		}
+		// Microsoft NTLM authentication only supported with curl handler
+		if (isset($options['auth'][2]) && 'ntlm' === $options['auth'][2]) {
+			throw new \InvalidArgumentException('Microsoft NTLM authentication only supported with curl handler');
+		}
+		$uri = $this->resolveHost($request, $options);
+		$contextResource = $this->createResource(static function () use($context, $params) {
+			return \stream_context_create($context, $params);
+		});
+		return $this->createResource(function () use($uri, &$http_response_header, $contextResource, $context, $options, $request) {
+			$resource = @\fopen((string) $uri, 'r', \false, $contextResource);
+			$this->lastHeaders = $http_response_header ?? [];
+			if (\false === $resource) {
+				throw new ConnectException(\sprintf('Connection refused for URI %s', $uri), $request, null, $context);
+			}
+			if (isset($options['read_timeout'])) {
+				$readTimeout = $options['read_timeout'];
+				$sec = (int) $readTimeout;
+				$usec = ($readTimeout - $sec) * 100000;
+				\stream_set_timeout($resource, $sec, $usec);
+			}
+			return $resource;
+		});
+	}
+	private function resolveHost(RequestInterface $request, array $options) : UriInterface
+	{
+		$uri = $request->getUri();
+		if (isset($options['force_ip_resolve']) && !\filter_var($uri->getHost(), \FILTER_VALIDATE_IP)) {
+			if ('v4' === $options['force_ip_resolve']) {
+				$records = \dns_get_record($uri->getHost(), \DNS_A);
+				if (\false === $records || !isset($records[0]['ip'])) {
+					throw new ConnectException(\sprintf("Could not resolve IPv4 address for host '%s'", $uri->getHost()), $request);
+				}
+				return $uri->withHost($records[0]['ip']);
+			}
+			if ('v6' === $options['force_ip_resolve']) {
+				$records = \dns_get_record($uri->getHost(), \DNS_AAAA);
+				if (\false === $records || !isset($records[0]['ipv6'])) {
+					throw new ConnectException(\sprintf("Could not resolve IPv6 address for host '%s'", $uri->getHost()), $request);
+				}
+				return $uri->withHost('[' . $records[0]['ipv6'] . ']');
+			}
+		}
+		return $uri;
+	}
+	private function getDefaultContext(RequestInterface $request) : array
+	{
+		$headers = '';
+		foreach ($request->getHeaders() as $name => $value) {
+			foreach ($value as $val) {
+				$headers .= "{$name}: {$val}\r\n";
+			}
+		}
+		$context = ['http' => ['method' => $request->getMethod(), 'header' => $headers, 'protocol_version' => $request->getProtocolVersion(), 'ignore_errors' => \true, 'follow_location' => 0], 'ssl' => ['peer_name' => $request->getUri()->getHost()]];
+		$body = (string) $request->getBody();
+		if ('' !== $body) {
+			$context['http']['content'] = $body;
+			// Prevent the HTTP handler from adding a Content-Type header.
+			if (!$request->hasHeader('Content-Type')) {
+				$context['http']['header'] .= "Content-Type:\r\n";
+			}
+		}
+		$context['http']['header'] = \rtrim($context['http']['header']);
+		return $context;
+	}
+	/**
+	 * @param mixed $value as passed via Request transfer options.
+	 */
+	private function add_proxy(RequestInterface $request, array &$options, $value, array &$params) : void
+	{
+		$uri = null;
+		if (!\is_array($value)) {
+			$uri = $value;
+		} else {
+			$scheme = $request->getUri()->getScheme();
+			if (isset($value[$scheme])) {
+				if (!isset($value['no']) || !Utils::isHostInNoProxy($request->getUri()->getHost(), $value['no'])) {
+					$uri = $value[$scheme];
+				}
+			}
+		}
+		if (!$uri) {
+			return;
+		}
+		$parsed = $this->parse_proxy($uri);
+		$options['http']['proxy'] = $parsed['proxy'];
+		if ($parsed['auth']) {
+			if (!isset($options['http']['header'])) {
+				$options['http']['header'] = [];
+			}
+			$options['http']['header'] .= "\r\nProxy-Authorization: {$parsed['auth']}";
+		}
+	}
+	/**
+	 * Parses the given proxy URL to make it compatible with the format PHP's stream context expects.
+	 */
+	private function parse_proxy(string $url) : array
+	{
+		$parsed = \parse_url($url);
+		if ($parsed !== \false && isset($parsed['scheme']) && $parsed['scheme'] === 'http') {
+			if (isset($parsed['host']) && isset($parsed['port'])) {
+				$auth = null;
+				if (isset($parsed['user']) && isset($parsed['pass'])) {
+					$auth = \base64_encode("{$parsed['user']}:{$parsed['pass']}");
+				}
+				return ['proxy' => "tcp://{$parsed['host']}:{$parsed['port']}", 'auth' => $auth ? "Basic {$auth}" : null];
+			}
+		}
+		// Return proxy as-is.
+		return ['proxy' => $url, 'auth' => null];
+	}
+	/**
+	 * @param mixed $value as passed via Request transfer options.
+	 */
+	private function add_timeout(RequestInterface $request, array &$options, $value, array &$params) : void
+	{
+		if ($value > 0) {
+			$options['http']['timeout'] = $value;
+		}
+	}
+	/**
+	 * @param mixed $value as passed via Request transfer options.
+	 */
+	private function add_crypto_method(RequestInterface $request, array &$options, $value, array &$params) : void
+	{
+		if ($value === \STREAM_CRYPTO_METHOD_TLSv1_0_CLIENT || $value === \STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT || $value === \STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT || \defined('STREAM_CRYPTO_METHOD_TLSv1_3_CLIENT') && $value === \STREAM_CRYPTO_METHOD_TLSv1_3_CLIENT) {
+			$options['http']['crypto_method'] = $value;
+			return;
+		}
+		throw new \InvalidArgumentException('Invalid crypto_method request option: unknown version provided');
+	}
+	/**
+	 * @param mixed $value as passed via Request transfer options.
+	 */
+	private function add_verify(RequestInterface $request, array &$options, $value, array &$params) : void
+	{
+		if ($value === \false) {
+			$options['ssl']['verify_peer'] = \false;
+			$options['ssl']['verify_peer_name'] = \false;
+			return;
+		}
+		if (\is_string($value)) {
+			$options['ssl']['cafile'] = $value;
+			if (!\file_exists($value)) {
+				throw new \RuntimeException("SSL CA bundle not found: {$value}");
+			}
+		} elseif ($value !== \true) {
+			throw new \InvalidArgumentException('Invalid verify request option');
+		}
+		$options['ssl']['verify_peer'] = \true;
+		$options['ssl']['verify_peer_name'] = \true;
+		$options['ssl']['allow_self_signed'] = \false;
+	}
+	/**
+	 * @param mixed $value as passed via Request transfer options.
+	 */
+	private function add_cert(RequestInterface $request, array &$options, $value, array &$params) : void
+	{
+		if (\is_array($value)) {
+			$options['ssl']['passphrase'] = $value[1];
+			$value = $value[0];
+		}
+		if (!\file_exists($value)) {
+			throw new \RuntimeException("SSL certificate not found: {$value}");
+		}
+		$options['ssl']['local_cert'] = $value;
+	}
+	/**
+	 * @param mixed $value as passed via Request transfer options.
+	 */
+	private function add_progress(RequestInterface $request, array &$options, $value, array &$params) : void
+	{
+		self::addNotification($params, static function ($code, $a, $b, $c, $transferred, $total) use($value) {
+			if ($code == \STREAM_NOTIFY_PROGRESS) {
+				// The upload progress cannot be determined. Use 0 for cURL compatibility:
+				// https://curl.se/libcurl/c/CURLOPT_PROGRESSFUNCTION.html
+				$value($total, $transferred, 0, 0);
+			}
+		});
+	}
+	/**
+	 * @param mixed $value as passed via Request transfer options.
+	 */
+	private function add_debug(RequestInterface $request, array &$options, $value, array &$params) : void
+	{
+		if ($value === \false) {
+			return;
+		}
+		static $map = [\STREAM_NOTIFY_CONNECT => 'CONNECT', \STREAM_NOTIFY_AUTH_REQUIRED => 'AUTH_REQUIRED', \STREAM_NOTIFY_AUTH_RESULT => 'AUTH_RESULT', \STREAM_NOTIFY_MIME_TYPE_IS => 'MIME_TYPE_IS', \STREAM_NOTIFY_FILE_SIZE_IS => 'FILE_SIZE_IS', \STREAM_NOTIFY_REDIRECTED => 'REDIRECTED', \STREAM_NOTIFY_PROGRESS => 'PROGRESS', \STREAM_NOTIFY_FAILURE => 'FAILURE', \STREAM_NOTIFY_COMPLETED => 'COMPLETED', \STREAM_NOTIFY_RESOLVE => 'RESOLVE'];
+		static $args = ['severity', 'message', 'message_code', 'bytes_transferred', 'bytes_max'];
+		$value = Utils::debugResource($value);
+		$ident = $request->getMethod() . ' ' . $request->getUri()->withFragment('');
+		self::addNotification($params, static function (int $code, ...$passed) use($ident, $value, $map, $args) : void {
+			\fprintf($value, '<%s> [%s] ', $ident, $map[$code]);
+			foreach (\array_filter($passed) as $i => $v) {
+				\fwrite($value, $args[$i] . ': "' . $v . '" ');
+			}
+			\fwrite($value, "\n");
+		});
+	}
+	private static function addNotification(array &$params, callable $notify) : void
+	{
+		// Wrap the existing function if needed.
+		if (!isset($params['notification'])) {
+			$params['notification'] = $notify;
+		} else {
+			$params['notification'] = self::callArray([$params['notification'], $notify]);
+		}
+	}
+	private static function callArray(array $functions) : callable
+	{
+		return static function (...$args) use($functions) {
+			foreach ($functions as $fn) {
+				$fn(...$args);
+			}
+		};
+	}
 }

lib/Vendor/GuzzleHttp/Handler/CurlMultiHandler.php

Indentation +213 added lines, -213 removed lines

@@ -19,217 +19,217 @@
  */
 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<int, float> An array of delay times, indexed by handle id in `addRequest`.
-     *
-     * @see CurlMultiHandler::addRequest
-     */
-    private $delays = [];
-    /**
-     * @var array<mixed> 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->factory = $options['handle_factory'] ?? new CurlFactory(50);
-        if (isset($options['select_timeout'])) {
-            $this->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 "select_timeout" instead.', \E_USER_DEPRECATED);
-            $this->selectTimeout = (int) $selectTimeout;
-        } else {
-            $this->selectTimeout = 1;
-        }
-        $this->options = $options['options'] ?? [];
-        // unsetting the property forces the first access to go through
-        // __get().
-        unset($this->_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("Can not get other property as '_mh'.");
-        }
-        $multiHandle = \curl_multi_init();
-        if (\false === $multiHandle) {
-            throw new \RuntimeException('Can not initialize curl multi handle.');
-        }
-        $this->_mh = $multiHandle;
-        foreach ($this->options as $option => $value) {
-            // A warning is raised in case of a wrong option.
-            \curl_multi_setopt($this->_mh, $option, $value);
-        }
-        return $this->_mh;
-    }
-    public function __destruct()
-    {
-        if (isset($this->_mh)) {
-            \curl_multi_close($this->_mh);
-            unset($this->_mh);
-        }
-    }
-    public function __invoke(RequestInterface $request, array $options) : PromiseInterface
-    {
-        $easy = $this->factory->create($request, $options);
-        $id = (int) $easy->handle;
-        $promise = new Promise([$this, 'execute'], function () use($id) {
-            return $this->cancel($id);
-        });
-        $this->addRequest(['easy' => $easy, 'deferred' => $promise]);
-        return $promise;
-    }
-    /**
-     * Ticks the curl event loop.
-     */
-    public function tick() : void
-    {
-        // Add any delayed handles if needed.
-        if ($this->delays) {
-            $currentTime = Utils::currentTime();
-            foreach ($this->delays as $id => $delay) {
-                if ($currentTime >= $delay) {
-                    unset($this->delays[$id]);
-                    \curl_multi_add_handle($this->_mh, $this->handles[$id]['easy']->handle);
-                }
-            }
-        }
-        // Run curl_multi_exec in the queue to enable other async tasks to run
-        P\Utils::queue()->add(Closure::fromCallable([$this, 'tickInQueue']));
-        // Step through the task queue which may add additional requests.
-        P\Utils::queue()->run();
-        if ($this->active && \curl_multi_select($this->_mh, $this->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->_mh, $this->active) === \CURLM_CALL_MULTI_PERFORM) {
-            // Prevent busy looping for slow HTTP requests.
-            \curl_multi_select($this->_mh, $this->selectTimeout);
-        }
-        $this->processMessages();
-    }
-    /**
-     * Runs \curl_multi_exec() inside the event loop, to prevent busy looping
-     */
-    private function tickInQueue() : void
-    {
-        if (\curl_multi_exec($this->_mh, $this->active) === \CURLM_CALL_MULTI_PERFORM) {
-            \curl_multi_select($this->_mh, 0);
-            P\Utils::queue()->add(Closure::fromCallable([$this, 'tickInQueue']));
-        }
-    }
-    /**
-     * Runs until all outstanding connections have completed.
-     */
-    public function execute() : void
-    {
-        $queue = P\Utils::queue();
-        while ($this->handles || !$queue->isEmpty()) {
-            // If there are no transfers, then sleep for the next delay
-            if (!$this->active && $this->delays) {
-                \usleep($this->timeToNext());
-            }
-            $this->tick();
-        }
-    }
-    private function addRequest(array $entry) : void
-    {
-        $easy = $entry['easy'];
-        $id = (int) $easy->handle;
-        $this->handles[$id] = $entry;
-        if (empty($easy->options['delay'])) {
-            \curl_multi_add_handle($this->_mh, $easy->handle);
-        } else {
-            $this->delays[$id] = Utils::currentTime() + $easy->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->handles[$id])) {
-            return \false;
-        }
-        $handle = $this->handles[$id]['easy']->handle;
-        unset($this->delays[$id], $this->handles[$id]);
-        \curl_multi_remove_handle($this->_mh, $handle);
-        \curl_close($handle);
-        return \true;
-    }
-    private function processMessages() : void
-    {
-        while ($done = \curl_multi_info_read($this->_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->_mh, $done['handle']);
-            if (!isset($this->handles[$id])) {
-                // Probably was cancelled.
-                continue;
-            }
-            $entry = $this->handles[$id];
-            unset($this->handles[$id], $this->delays[$id]);
-            $entry['easy']->errno = $done['result'];
-            $entry['deferred']->resolve(CurlFactory::finish($this, $entry['easy'], $this->factory));
-        }
-    }
-    private function timeToNext() : int
-    {
-        $currentTime = Utils::currentTime();
-        $nextTime = \PHP_INT_MAX;
-        foreach ($this->delays as $time) {
-            if ($time < $nextTime) {
-                $nextTime = $time;
-            }
-        }
-        return (int) \max(0, $nextTime - $currentTime) * 1000000;
-    }
+	/**
+	 * @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<int, float> An array of delay times, indexed by handle id in `addRequest`.
+	 *
+	 * @see CurlMultiHandler::addRequest
+	 */
+	private $delays = [];
+	/**
+	 * @var array<mixed> 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->factory = $options['handle_factory'] ?? new CurlFactory(50);
+		if (isset($options['select_timeout'])) {
+			$this->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 "select_timeout" instead.', \E_USER_DEPRECATED);
+			$this->selectTimeout = (int) $selectTimeout;
+		} else {
+			$this->selectTimeout = 1;
+		}
+		$this->options = $options['options'] ?? [];
+		// unsetting the property forces the first access to go through
+		// __get().
+		unset($this->_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("Can not get other property as '_mh'.");
+		}
+		$multiHandle = \curl_multi_init();
+		if (\false === $multiHandle) {
+			throw new \RuntimeException('Can not initialize curl multi handle.');
+		}
+		$this->_mh = $multiHandle;
+		foreach ($this->options as $option => $value) {
+			// A warning is raised in case of a wrong option.
+			\curl_multi_setopt($this->_mh, $option, $value);
+		}
+		return $this->_mh;
+	}
+	public function __destruct()
+	{
+		if (isset($this->_mh)) {
+			\curl_multi_close($this->_mh);
+			unset($this->_mh);
+		}
+	}
+	public function __invoke(RequestInterface $request, array $options) : PromiseInterface
+	{
+		$easy = $this->factory->create($request, $options);
+		$id = (int) $easy->handle;
+		$promise = new Promise([$this, 'execute'], function () use($id) {
+			return $this->cancel($id);
+		});
+		$this->addRequest(['easy' => $easy, 'deferred' => $promise]);
+		return $promise;
+	}
+	/**
+	 * Ticks the curl event loop.
+	 */
+	public function tick() : void
+	{
+		// Add any delayed handles if needed.
+		if ($this->delays) {
+			$currentTime = Utils::currentTime();
+			foreach ($this->delays as $id => $delay) {
+				if ($currentTime >= $delay) {
+					unset($this->delays[$id]);
+					\curl_multi_add_handle($this->_mh, $this->handles[$id]['easy']->handle);
+				}
+			}
+		}
+		// Run curl_multi_exec in the queue to enable other async tasks to run
+		P\Utils::queue()->add(Closure::fromCallable([$this, 'tickInQueue']));
+		// Step through the task queue which may add additional requests.
+		P\Utils::queue()->run();
+		if ($this->active && \curl_multi_select($this->_mh, $this->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->_mh, $this->active) === \CURLM_CALL_MULTI_PERFORM) {
+			// Prevent busy looping for slow HTTP requests.
+			\curl_multi_select($this->_mh, $this->selectTimeout);
+		}
+		$this->processMessages();
+	}
+	/**
+	 * Runs \curl_multi_exec() inside the event loop, to prevent busy looping
+	 */
+	private function tickInQueue() : void
+	{
+		if (\curl_multi_exec($this->_mh, $this->active) === \CURLM_CALL_MULTI_PERFORM) {
+			\curl_multi_select($this->_mh, 0);
+			P\Utils::queue()->add(Closure::fromCallable([$this, 'tickInQueue']));
+		}
+	}
+	/**
+	 * Runs until all outstanding connections have completed.
+	 */
+	public function execute() : void
+	{
+		$queue = P\Utils::queue();
+		while ($this->handles || !$queue->isEmpty()) {
+			// If there are no transfers, then sleep for the next delay
+			if (!$this->active && $this->delays) {
+				\usleep($this->timeToNext());
+			}
+			$this->tick();
+		}
+	}
+	private function addRequest(array $entry) : void
+	{
+		$easy = $entry['easy'];
+		$id = (int) $easy->handle;
+		$this->handles[$id] = $entry;
+		if (empty($easy->options['delay'])) {
+			\curl_multi_add_handle($this->_mh, $easy->handle);
+		} else {
+			$this->delays[$id] = Utils::currentTime() + $easy->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->handles[$id])) {
+			return \false;
+		}
+		$handle = $this->handles[$id]['easy']->handle;
+		unset($this->delays[$id], $this->handles[$id]);
+		\curl_multi_remove_handle($this->_mh, $handle);
+		\curl_close($handle);
+		return \true;
+	}
+	private function processMessages() : void
+	{
+		while ($done = \curl_multi_info_read($this->_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->_mh, $done['handle']);
+			if (!isset($this->handles[$id])) {
+				// Probably was cancelled.
+				continue;
+			}
+			$entry = $this->handles[$id];
+			unset($this->handles[$id], $this->delays[$id]);
+			$entry['easy']->errno = $done['result'];
+			$entry['deferred']->resolve(CurlFactory::finish($this, $entry['easy'], $this->factory));
+		}
+	}
+	private function timeToNext() : int
+	{
+		$currentTime = Utils::currentTime();
+		$nextTime = \PHP_INT_MAX;
+		foreach ($this->delays as $time) {
+			if ($time < $nextTime) {
+				$nextTime = $time;
+			}
+		}
+		return (int) \max(0, $nextTime - $currentTime) * 1000000;
+	}
 }

lib/Vendor/GuzzleHttp/Handler/MockHandler.php

Indentation +153 added lines, -153 removed lines

@@ -18,157 +18,157 @@
  */
 class MockHandler implements \Countable
 {
-    /**
-     * @var array
-     */
-    private $queue = [];
-    /**
-     * @var RequestInterface|null
-     */
-    private $lastRequest;
-    /**
-     * @var array
-     */
-    private $lastOptions = [];
-    /**
-     * @var callable|null
-     */
-    private $onFulfilled;
-    /**
-     * @var callable|null
-     */
-    private $onRejected;
-    /**
-     * Creates a new MockHandler that uses the default handler stack list of
-     * middlewares.
-     *
-     * @param array|null    $queue       Array of responses, callables, or exceptions.
-     * @param callable|null $onFulfilled Callback to invoke when the return value is fulfilled.
-     * @param callable|null $onRejected  Callback to invoke when the return value is rejected.
-     */
-    public static function createWithMiddleware(?array $queue = null, ?callable $onFulfilled = null, ?callable $onRejected = null) : HandlerStack
-    {
-        return HandlerStack::create(new self($queue, $onFulfilled, $onRejected));
-    }
-    /**
-     * The passed in value must be an array of
-     * {@see ResponseInterface} objects, Exceptions,
-     * callables, or Promises.
-     *
-     * @param array<int, mixed>|null $queue       The parameters to be passed to the append function, as an indexed array.
-     * @param callable|null          $onFulfilled Callback to invoke when the return value is fulfilled.
-     * @param callable|null          $onRejected  Callback to invoke when the return value is rejected.
-     */
-    public function __construct(?array $queue = null, ?callable $onFulfilled = null, ?callable $onRejected = null)
-    {
-        $this->onFulfilled = $onFulfilled;
-        $this->onRejected = $onRejected;
-        if ($queue) {
-            // array_values included for BC
-            $this->append(...\array_values($queue));
-        }
-    }
-    public function __invoke(RequestInterface $request, array $options) : PromiseInterface
-    {
-        if (!$this->queue) {
-            throw new \OutOfBoundsException('Mock queue is empty');
-        }
-        if (isset($options['delay']) && \is_numeric($options['delay'])) {
-            \usleep((int) $options['delay'] * 1000);
-        }
-        $this->lastRequest = $request;
-        $this->lastOptions = $options;
-        $response = \array_shift($this->queue);
-        if (isset($options['on_headers'])) {
-            if (!\is_callable($options['on_headers'])) {
-                throw new \InvalidArgumentException('on_headers must be callable');
-            }
-            try {
-                $options['on_headers']($response);
-            } catch (\Exception $e) {
-                $msg = 'An error was encountered during the on_headers event';
-                $response = new RequestException($msg, $request, $response, $e);
-            }
-        }
-        if (\is_callable($response)) {
-            $response = $response($request, $options);
-        }
-        $response = $response instanceof \Throwable ? P\Create::rejectionFor($response) : P\Create::promiseFor($response);
-        return $response->then(function (?ResponseInterface $value) use($request, $options) {
-            $this->invokeStats($request, $options, $value);
-            if ($this->onFulfilled) {
-                ($this->onFulfilled)($value);
-            }
-            if ($value !== null && isset($options['sink'])) {
-                $contents = (string) $value->getBody();
-                $sink = $options['sink'];
-                if (\is_resource($sink)) {
-                    \fwrite($sink, $contents);
-                } elseif (\is_string($sink)) {
-                    \file_put_contents($sink, $contents);
-                } elseif ($sink instanceof StreamInterface) {
-                    $sink->write($contents);
-                }
-            }
-            return $value;
-        }, function ($reason) use($request, $options) {
-            $this->invokeStats($request, $options, null, $reason);
-            if ($this->onRejected) {
-                ($this->onRejected)($reason);
-            }
-            return P\Create::rejectionFor($reason);
-        });
-    }
-    /**
-     * Adds one or more variadic requests, exceptions, callables, or promises
-     * to the queue.
-     *
-     * @param mixed ...$values
-     */
-    public function append(...$values) : void
-    {
-        foreach ($values as $value) {
-            if ($value instanceof ResponseInterface || $value instanceof \Throwable || $value instanceof PromiseInterface || \is_callable($value)) {
-                $this->queue[] = $value;
-            } else {
-                throw new \TypeError('Expected a Response, Promise, Throwable or callable. Found ' . Utils::describeType($value));
-            }
-        }
-    }
-    /**
-     * Get the last received request.
-     */
-    public function getLastRequest() : ?RequestInterface
-    {
-        return $this->lastRequest;
-    }
-    /**
-     * Get the last received request options.
-     */
-    public function getLastOptions() : array
-    {
-        return $this->lastOptions;
-    }
-    /**
-     * Returns the number of remaining items in the queue.
-     */
-    public function count() : int
-    {
-        return \count($this->queue);
-    }
-    public function reset() : void
-    {
-        $this->queue = [];
-    }
-    /**
-     * @param mixed $reason Promise or reason.
-     */
-    private function invokeStats(RequestInterface $request, array $options, ?ResponseInterface $response = null, $reason = null) : void
-    {
-        if (isset($options['on_stats'])) {
-            $transferTime = $options['transfer_time'] ?? 0;
-            $stats = new TransferStats($request, $response, $transferTime, $reason);
-            $options['on_stats']($stats);
-        }
-    }
+	/**
+	 * @var array
+	 */
+	private $queue = [];
+	/**
+	 * @var RequestInterface|null
+	 */
+	private $lastRequest;
+	/**
+	 * @var array
+	 */
+	private $lastOptions = [];
+	/**
+	 * @var callable|null
+	 */
+	private $onFulfilled;
+	/**
+	 * @var callable|null
+	 */
+	private $onRejected;
+	/**
+	 * Creates a new MockHandler that uses the default handler stack list of
+	 * middlewares.
+	 *
+	 * @param array|null    $queue       Array of responses, callables, or exceptions.
+	 * @param callable|null $onFulfilled Callback to invoke when the return value is fulfilled.
+	 * @param callable|null $onRejected  Callback to invoke when the return value is rejected.
+	 */
+	public static function createWithMiddleware(?array $queue = null, ?callable $onFulfilled = null, ?callable $onRejected = null) : HandlerStack
+	{
+		return HandlerStack::create(new self($queue, $onFulfilled, $onRejected));
+	}
+	/**
+	 * The passed in value must be an array of
+	 * {@see ResponseInterface} objects, Exceptions,
+	 * callables, or Promises.
+	 *
+	 * @param array<int, mixed>|null $queue       The parameters to be passed to the append function, as an indexed array.
+	 * @param callable|null          $onFulfilled Callback to invoke when the return value is fulfilled.
+	 * @param callable|null          $onRejected  Callback to invoke when the return value is rejected.
+	 */
+	public function __construct(?array $queue = null, ?callable $onFulfilled = null, ?callable $onRejected = null)
+	{
+		$this->onFulfilled = $onFulfilled;
+		$this->onRejected = $onRejected;
+		if ($queue) {
+			// array_values included for BC
+			$this->append(...\array_values($queue));
+		}
+	}
+	public function __invoke(RequestInterface $request, array $options) : PromiseInterface
+	{
+		if (!$this->queue) {
+			throw new \OutOfBoundsException('Mock queue is empty');
+		}
+		if (isset($options['delay']) && \is_numeric($options['delay'])) {
+			\usleep((int) $options['delay'] * 1000);
+		}
+		$this->lastRequest = $request;
+		$this->lastOptions = $options;
+		$response = \array_shift($this->queue);
+		if (isset($options['on_headers'])) {
+			if (!\is_callable($options['on_headers'])) {
+				throw new \InvalidArgumentException('on_headers must be callable');
+			}
+			try {
+				$options['on_headers']($response);
+			} catch (\Exception $e) {
+				$msg = 'An error was encountered during the on_headers event';
+				$response = new RequestException($msg, $request, $response, $e);
+			}
+		}
+		if (\is_callable($response)) {
+			$response = $response($request, $options);
+		}
+		$response = $response instanceof \Throwable ? P\Create::rejectionFor($response) : P\Create::promiseFor($response);
+		return $response->then(function (?ResponseInterface $value) use($request, $options) {
+			$this->invokeStats($request, $options, $value);
+			if ($this->onFulfilled) {
+				($this->onFulfilled)($value);
+			}
+			if ($value !== null && isset($options['sink'])) {
+				$contents = (string) $value->getBody();
+				$sink = $options['sink'];
+				if (\is_resource($sink)) {
+					\fwrite($sink, $contents);
+				} elseif (\is_string($sink)) {
+					\file_put_contents($sink, $contents);
+				} elseif ($sink instanceof StreamInterface) {
+					$sink->write($contents);
+				}
+			}
+			return $value;
+		}, function ($reason) use($request, $options) {
+			$this->invokeStats($request, $options, null, $reason);
+			if ($this->onRejected) {
+				($this->onRejected)($reason);
+			}
+			return P\Create::rejectionFor($reason);
+		});
+	}
+	/**
+	 * Adds one or more variadic requests, exceptions, callables, or promises
+	 * to the queue.
+	 *
+	 * @param mixed ...$values
+	 */
+	public function append(...$values) : void
+	{
+		foreach ($values as $value) {
+			if ($value instanceof ResponseInterface || $value instanceof \Throwable || $value instanceof PromiseInterface || \is_callable($value)) {
+				$this->queue[] = $value;
+			} else {
+				throw new \TypeError('Expected a Response, Promise, Throwable or callable. Found ' . Utils::describeType($value));
+			}
+		}
+	}
+	/**
+	 * Get the last received request.
+	 */
+	public function getLastRequest() : ?RequestInterface
+	{
+		return $this->lastRequest;
+	}
+	/**
+	 * Get the last received request options.
+	 */
+	public function getLastOptions() : array
+	{
+		return $this->lastOptions;
+	}
+	/**
+	 * Returns the number of remaining items in the queue.
+	 */
+	public function count() : int
+	{
+		return \count($this->queue);
+	}
+	public function reset() : void
+	{
+		$this->queue = [];
+	}
+	/**
+	 * @param mixed $reason Promise or reason.
+	 */
+	private function invokeStats(RequestInterface $request, array $options, ?ResponseInterface $response = null, $reason = null) : void
+	{
+		if (isset($options['on_stats'])) {
+			$transferTime = $options['transfer_time'] ?? 0;
+			$stats = new TransferStats($request, $response, $transferTime, $reason);
+			$options['on_stats']($stats);
+		}
+	}
 }

lib/Vendor/GuzzleHttp/Handler/CurlFactory.php

Indentation +541 added lines, -541 removed lines

@@ -19,545 +19,545 @@
  */
 class CurlFactory implements CurlFactoryInterface
 {
-    public const CURL_VERSION_STR = 'curl_version';
-    /**
-     * @deprecated
-     */
-    public const LOW_CURL_VERSION_NUMBER = '7.21.2';
-    /**
-     * @var resource[]|\CurlHandle[]
-     */
-    private $handles = [];
-    /**
-     * @var int Total number of idle handles to keep in cache
-     */
-    private $maxHandles;
-    /**
-     * @param int $maxHandles Maximum number of idle handles.
-     */
-    public function __construct(int $maxHandles)
-    {
-        $this->maxHandles = $maxHandles;
-    }
-    public function create(RequestInterface $request, array $options) : EasyHandle
-    {
-        $protocolVersion = $request->getProtocolVersion();
-        if ('2' === $protocolVersion || '2.0' === $protocolVersion) {
-            if (!self::supportsHttp2()) {
-                throw new ConnectException('HTTP/2 is supported by the cURL handler, however libcurl is built without HTTP/2 support.', $request);
-            }
-        } elseif ('1.0' !== $protocolVersion && '1.1' !== $protocolVersion) {
-            throw new ConnectException(\sprintf('HTTP/%s is not supported by the cURL handler.', $protocolVersion), $request);
-        }
-        if (isset($options['curl']['body_as_string'])) {
-            $options['_body_as_string'] = $options['curl']['body_as_string'];
-            unset($options['curl']['body_as_string']);
-        }
-        $easy = new EasyHandle();
-        $easy->request = $request;
-        $easy->options = $options;
-        $conf = $this->getDefaultConf($easy);
-        $this->applyMethod($easy, $conf);
-        $this->applyHandlerOptions($easy, $conf);
-        $this->applyHeaders($easy, $conf);
-        unset($conf['_headers']);
-        // Add handler options from the request configuration options
-        if (isset($options['curl'])) {
-            $conf = \array_replace($conf, $options['curl']);
-        }
-        $conf[\CURLOPT_HEADERFUNCTION] = $this->createHeaderFn($easy);
-        $easy->handle = $this->handles ? \array_pop($this->handles) : \curl_init();
-        \curl_setopt_array($easy->handle, $conf);
-        return $easy;
-    }
-    private static function supportsHttp2() : bool
-    {
-        static $supportsHttp2 = null;
-        if (null === $supportsHttp2) {
-            $supportsHttp2 = self::supportsTls12() && \defined('CURL_VERSION_HTTP2') && \CURL_VERSION_HTTP2 & \curl_version()['features'];
-        }
-        return $supportsHttp2;
-    }
-    private static function supportsTls12() : bool
-    {
-        static $supportsTls12 = null;
-        if (null === $supportsTls12) {
-            $supportsTls12 = \CURL_SSLVERSION_TLSv1_2 & \curl_version()['features'];
-        }
-        return $supportsTls12;
-    }
-    private static function supportsTls13() : bool
-    {
-        static $supportsTls13 = null;
-        if (null === $supportsTls13) {
-            $supportsTls13 = \defined('CURL_SSLVERSION_TLSv1_3') && \CURL_SSLVERSION_TLSv1_3 & \curl_version()['features'];
-        }
-        return $supportsTls13;
-    }
-    public function release(EasyHandle $easy) : void
-    {
-        $resource = $easy->handle;
-        unset($easy->handle);
-        if (\count($this->handles) >= $this->maxHandles) {
-            \curl_close($resource);
-        } else {
-            // Remove all callback functions as they can hold onto references
-            // and are not cleaned up by curl_reset. Using curl_setopt_array
-            // does not work for some reason, so removing each one
-            // individually.
-            \curl_setopt($resource, \CURLOPT_HEADERFUNCTION, null);
-            \curl_setopt($resource, \CURLOPT_READFUNCTION, null);
-            \curl_setopt($resource, \CURLOPT_WRITEFUNCTION, null);
-            \curl_setopt($resource, \CURLOPT_PROGRESSFUNCTION, null);
-            \curl_reset($resource);
-            $this->handles[] = $resource;
-        }
-    }
-    /**
-     * Completes a cURL transaction, either returning a response promise or a
-     * rejected promise.
-     *
-     * @param callable(RequestInterface, array): PromiseInterface $handler
-     * @param CurlFactoryInterface                                $factory Dictates how the handle is released
-     */
-    public static function finish(callable $handler, EasyHandle $easy, CurlFactoryInterface $factory) : PromiseInterface
-    {
-        if (isset($easy->options['on_stats'])) {
-            self::invokeStats($easy);
-        }
-        if (!$easy->response || $easy->errno) {
-            return self::finishError($handler, $easy, $factory);
-        }
-        // Return the response if it is present and there is no error.
-        $factory->release($easy);
-        // Rewind the body of the response if possible.
-        $body = $easy->response->getBody();
-        if ($body->isSeekable()) {
-            $body->rewind();
-        }
-        return new FulfilledPromise($easy->response);
-    }
-    private static function invokeStats(EasyHandle $easy) : void
-    {
-        $curlStats = \curl_getinfo($easy->handle);
-        $curlStats['appconnect_time'] = \curl_getinfo($easy->handle, \CURLINFO_APPCONNECT_TIME);
-        $stats = new TransferStats($easy->request, $easy->response, $curlStats['total_time'], $easy->errno, $curlStats);
-        $easy->options['on_stats']($stats);
-    }
-    /**
-     * @param callable(RequestInterface, array): PromiseInterface $handler
-     */
-    private static function finishError(callable $handler, EasyHandle $easy, CurlFactoryInterface $factory) : PromiseInterface
-    {
-        // Get error information and release the handle to the factory.
-        $ctx = ['errno' => $easy->errno, 'error' => \curl_error($easy->handle), 'appconnect_time' => \curl_getinfo($easy->handle, \CURLINFO_APPCONNECT_TIME)] + \curl_getinfo($easy->handle);
-        $ctx[self::CURL_VERSION_STR] = self::getCurlVersion();
-        $factory->release($easy);
-        // Retry when nothing is present or when curl failed to rewind.
-        if (empty($easy->options['_err_message']) && (!$easy->errno || $easy->errno == 65)) {
-            return self::retryFailedRewind($handler, $easy, $ctx);
-        }
-        return self::createRejection($easy, $ctx);
-    }
-    private static function getCurlVersion() : string
-    {
-        static $curlVersion = null;
-        if (null === $curlVersion) {
-            $curlVersion = \curl_version()['version'];
-        }
-        return $curlVersion;
-    }
-    private static function createRejection(EasyHandle $easy, array $ctx) : PromiseInterface
-    {
-        static $connectionErrors = [\CURLE_OPERATION_TIMEOUTED => \true, \CURLE_COULDNT_RESOLVE_HOST => \true, \CURLE_COULDNT_CONNECT => \true, \CURLE_SSL_CONNECT_ERROR => \true, \CURLE_GOT_NOTHING => \true];
-        if ($easy->createResponseException) {
-            return P\Create::rejectionFor(new RequestException('An error was encountered while creating the response', $easy->request, $easy->response, $easy->createResponseException, $ctx));
-        }
-        // If an exception was encountered during the onHeaders event, then
-        // return a rejected promise that wraps that exception.
-        if ($easy->onHeadersException) {
-            return P\Create::rejectionFor(new RequestException('An error was encountered during the on_headers event', $easy->request, $easy->response, $easy->onHeadersException, $ctx));
-        }
-        $uri = $easy->request->getUri();
-        $sanitizedError = self::sanitizeCurlError($ctx['error'] ?? '', $uri);
-        $message = \sprintf('cURL error %s: %s (%s)', $ctx['errno'], $sanitizedError, 'see https://curl.haxx.se/libcurl/c/libcurl-errors.html');
-        if ('' !== $sanitizedError) {
-            $redactedUriString = \OCA\FullTextSearch_Elasticsearch\Vendor\GuzzleHttp\Psr7\Utils::redactUserInfo($uri)->__toString();
-            if ($redactedUriString !== '' && \false === \strpos($sanitizedError, $redactedUriString)) {
-                $message .= \sprintf(' for %s', $redactedUriString);
-            }
-        }
-        // Create a connection exception if it was a specific error code.
-        $error = isset($connectionErrors[$easy->errno]) ? new ConnectException($message, $easy->request, null, $ctx) : new RequestException($message, $easy->request, $easy->response, null, $ctx);
-        return P\Create::rejectionFor($error);
-    }
-    private static function sanitizeCurlError(string $error, UriInterface $uri) : string
-    {
-        if ('' === $error) {
-            return $error;
-        }
-        $baseUri = $uri->withQuery('')->withFragment('');
-        $baseUriString = $baseUri->__toString();
-        if ('' === $baseUriString) {
-            return $error;
-        }
-        $redactedUriString = \OCA\FullTextSearch_Elasticsearch\Vendor\GuzzleHttp\Psr7\Utils::redactUserInfo($baseUri)->__toString();
-        return \str_replace($baseUriString, $redactedUriString, $error);
-    }
-    /**
-     * @return array<int|string, mixed>
-     */
-    private function getDefaultConf(EasyHandle $easy) : array
-    {
-        $conf = ['_headers' => $easy->request->getHeaders(), \CURLOPT_CUSTOMREQUEST => $easy->request->getMethod(), \CURLOPT_URL => (string) $easy->request->getUri()->withFragment(''), \CURLOPT_RETURNTRANSFER => \false, \CURLOPT_HEADER => \false, \CURLOPT_CONNECTTIMEOUT => 300];
-        if (\defined('CURLOPT_PROTOCOLS')) {
-            $conf[\CURLOPT_PROTOCOLS] = \CURLPROTO_HTTP | \CURLPROTO_HTTPS;
-        }
-        $version = $easy->request->getProtocolVersion();
-        if ('2' === $version || '2.0' === $version) {
-            $conf[\CURLOPT_HTTP_VERSION] = \CURL_HTTP_VERSION_2_0;
-        } elseif ('1.1' === $version) {
-            $conf[\CURLOPT_HTTP_VERSION] = \CURL_HTTP_VERSION_1_1;
-        } else {
-            $conf[\CURLOPT_HTTP_VERSION] = \CURL_HTTP_VERSION_1_0;
-        }
-        return $conf;
-    }
-    private function applyMethod(EasyHandle $easy, array &$conf) : void
-    {
-        $body = $easy->request->getBody();
-        $size = $body->getSize();
-        if ($size === null || $size > 0) {
-            $this->applyBody($easy->request, $easy->options, $conf);
-            return;
-        }
-        $method = $easy->request->getMethod();
-        if ($method === 'PUT' || $method === 'POST') {
-            // See https://datatracker.ietf.org/doc/html/rfc7230#section-3.3.2
-            if (!$easy->request->hasHeader('Content-Length')) {
-                $conf[\CURLOPT_HTTPHEADER][] = 'Content-Length: 0';
-            }
-        } elseif ($method === 'HEAD') {
-            $conf[\CURLOPT_NOBODY] = \true;
-            unset($conf[\CURLOPT_WRITEFUNCTION], $conf[\CURLOPT_READFUNCTION], $conf[\CURLOPT_FILE], $conf[\CURLOPT_INFILE]);
-        }
-    }
-    private function applyBody(RequestInterface $request, array $options, array &$conf) : void
-    {
-        $size = $request->hasHeader('Content-Length') ? (int) $request->getHeaderLine('Content-Length') : null;
-        // Send the body as a string if the size is less than 1MB OR if the
-        // [curl][body_as_string] request value is set.
-        if ($size !== null && $size < 1000000 || !empty($options['_body_as_string'])) {
-            $conf[\CURLOPT_POSTFIELDS] = (string) $request->getBody();
-            // Don't duplicate the Content-Length header
-            $this->removeHeader('Content-Length', $conf);
-            $this->removeHeader('Transfer-Encoding', $conf);
-        } else {
-            $conf[\CURLOPT_UPLOAD] = \true;
-            if ($size !== null) {
-                $conf[\CURLOPT_INFILESIZE] = $size;
-                $this->removeHeader('Content-Length', $conf);
-            }
-            $body = $request->getBody();
-            if ($body->isSeekable()) {
-                $body->rewind();
-            }
-            $conf[\CURLOPT_READFUNCTION] = static function ($ch, $fd, $length) use($body) {
-                return $body->read($length);
-            };
-        }
-        // If the Expect header is not present, prevent curl from adding it
-        if (!$request->hasHeader('Expect')) {
-            $conf[\CURLOPT_HTTPHEADER][] = 'Expect:';
-        }
-        // cURL sometimes adds a content-type by default. Prevent this.
-        if (!$request->hasHeader('Content-Type')) {
-            $conf[\CURLOPT_HTTPHEADER][] = 'Content-Type:';
-        }
-    }
-    private function applyHeaders(EasyHandle $easy, array &$conf) : void
-    {
-        foreach ($conf['_headers'] as $name => $values) {
-            foreach ($values as $value) {
-                $value = (string) $value;
-                if ($value === '') {
-                    // cURL requires a special format for empty headers.
-                    // See https://github.com/guzzle/guzzle/issues/1882 for more details.
-                    $conf[\CURLOPT_HTTPHEADER][] = "{$name};";
-                } else {
-                    $conf[\CURLOPT_HTTPHEADER][] = "{$name}: {$value}";
-                }
-            }
-        }
-        // Remove the Accept header if one was not set
-        if (!$easy->request->hasHeader('Accept')) {
-            $conf[\CURLOPT_HTTPHEADER][] = 'Accept:';
-        }
-    }
-    /**
-     * Remove a header from the options array.
-     *
-     * @param string $name    Case-insensitive header to remove
-     * @param array  $options Array of options to modify
-     */
-    private function removeHeader(string $name, array &$options) : void
-    {
-        foreach (\array_keys($options['_headers']) as $key) {
-            if (!\strcasecmp($key, $name)) {
-                unset($options['_headers'][$key]);
-                return;
-            }
-        }
-    }
-    private function applyHandlerOptions(EasyHandle $easy, array &$conf) : void
-    {
-        $options = $easy->options;
-        if (isset($options['verify'])) {
-            if ($options['verify'] === \false) {
-                unset($conf[\CURLOPT_CAINFO]);
-                $conf[\CURLOPT_SSL_VERIFYHOST] = 0;
-                $conf[\CURLOPT_SSL_VERIFYPEER] = \false;
-            } else {
-                $conf[\CURLOPT_SSL_VERIFYHOST] = 2;
-                $conf[\CURLOPT_SSL_VERIFYPEER] = \true;
-                if (\is_string($options['verify'])) {
-                    // Throw an error if the file/folder/link path is not valid or doesn't exist.
-                    if (!\file_exists($options['verify'])) {
-                        throw new \InvalidArgumentException("SSL CA bundle not found: {$options['verify']}");
-                    }
-                    // If it's a directory or a link to a directory use CURLOPT_CAPATH.
-                    // If not, it's probably a file, or a link to a file, so use CURLOPT_CAINFO.
-                    if (\is_dir($options['verify']) || \is_link($options['verify']) === \true && ($verifyLink = \readlink($options['verify'])) !== \false && \is_dir($verifyLink)) {
-                        $conf[\CURLOPT_CAPATH] = $options['verify'];
-                    } else {
-                        $conf[\CURLOPT_CAINFO] = $options['verify'];
-                    }
-                }
-            }
-        }
-        if (!isset($options['curl'][\CURLOPT_ENCODING]) && !empty($options['decode_content'])) {
-            $accept = $easy->request->getHeaderLine('Accept-Encoding');
-            if ($accept) {
-                $conf[\CURLOPT_ENCODING] = $accept;
-            } else {
-                // The empty string enables all available decoders and implicitly
-                // sets a matching 'Accept-Encoding' header.
-                $conf[\CURLOPT_ENCODING] = '';
-                // But as the user did not specify any encoding preference,
-                // let's leave it up to server by preventing curl from sending
-                // the header, which will be interpreted as 'Accept-Encoding: *'.
-                // https://www.rfc-editor.org/rfc/rfc9110#field.accept-encoding
-                $conf[\CURLOPT_HTTPHEADER][] = 'Accept-Encoding:';
-            }
-        }
-        if (!isset($options['sink'])) {
-            // Use a default temp stream if no sink was set.
-            $options['sink'] = \OCA\FullTextSearch_Elasticsearch\Vendor\GuzzleHttp\Psr7\Utils::tryFopen('php://temp', 'w+');
-        }
-        $sink = $options['sink'];
-        if (!\is_string($sink)) {
-            $sink = \OCA\FullTextSearch_Elasticsearch\Vendor\GuzzleHttp\Psr7\Utils::streamFor($sink);
-        } elseif (!\is_dir(\dirname($sink))) {
-            // Ensure that the directory exists before failing in curl.
-            throw new \RuntimeException(\sprintf('Directory %s does not exist for sink value of %s', \dirname($sink), $sink));
-        } else {
-            $sink = new LazyOpenStream($sink, 'w+');
-        }
-        $easy->sink = $sink;
-        $conf[\CURLOPT_WRITEFUNCTION] = static function ($ch, $write) use($sink) : int {
-            return $sink->write($write);
-        };
-        $timeoutRequiresNoSignal = \false;
-        if (isset($options['timeout'])) {
-            $timeoutRequiresNoSignal |= $options['timeout'] < 1;
-            $conf[\CURLOPT_TIMEOUT_MS] = $options['timeout'] * 1000;
-        }
-        // CURL default value is CURL_IPRESOLVE_WHATEVER
-        if (isset($options['force_ip_resolve'])) {
-            if ('v4' === $options['force_ip_resolve']) {
-                $conf[\CURLOPT_IPRESOLVE] = \CURL_IPRESOLVE_V4;
-            } elseif ('v6' === $options['force_ip_resolve']) {
-                $conf[\CURLOPT_IPRESOLVE] = \CURL_IPRESOLVE_V6;
-            }
-        }
-        if (isset($options['connect_timeout'])) {
-            $timeoutRequiresNoSignal |= $options['connect_timeout'] < 1;
-            $conf[\CURLOPT_CONNECTTIMEOUT_MS] = $options['connect_timeout'] * 1000;
-        }
-        if ($timeoutRequiresNoSignal && \strtoupper(\substr(\PHP_OS, 0, 3)) !== 'WIN') {
-            $conf[\CURLOPT_NOSIGNAL] = \true;
-        }
-        if (isset($options['proxy'])) {
-            if (!\is_array($options['proxy'])) {
-                $conf[\CURLOPT_PROXY] = $options['proxy'];
-            } else {
-                $scheme = $easy->request->getUri()->getScheme();
-                if (isset($options['proxy'][$scheme])) {
-                    $host = $easy->request->getUri()->getHost();
-                    if (isset($options['proxy']['no']) && Utils::isHostInNoProxy($host, $options['proxy']['no'])) {
-                        unset($conf[\CURLOPT_PROXY]);
-                    } else {
-                        $conf[\CURLOPT_PROXY] = $options['proxy'][$scheme];
-                    }
-                }
-            }
-        }
-        if (isset($options['crypto_method'])) {
-            $protocolVersion = $easy->request->getProtocolVersion();
-            // If HTTP/2, upgrade TLS 1.0 and 1.1 to 1.2
-            if ('2' === $protocolVersion || '2.0' === $protocolVersion) {
-                if (\STREAM_CRYPTO_METHOD_TLSv1_0_CLIENT === $options['crypto_method'] || \STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT === $options['crypto_method'] || \STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT === $options['crypto_method']) {
-                    $conf[\CURLOPT_SSLVERSION] = \CURL_SSLVERSION_TLSv1_2;
-                } elseif (\defined('STREAM_CRYPTO_METHOD_TLSv1_3_CLIENT') && \STREAM_CRYPTO_METHOD_TLSv1_3_CLIENT === $options['crypto_method']) {
-                    if (!self::supportsTls13()) {
-                        throw new \InvalidArgumentException('Invalid crypto_method request option: TLS 1.3 not supported by your version of cURL');
-                    }
-                    $conf[\CURLOPT_SSLVERSION] = \CURL_SSLVERSION_TLSv1_3;
-                } else {
-                    throw new \InvalidArgumentException('Invalid crypto_method request option: unknown version provided');
-                }
-            } elseif (\STREAM_CRYPTO_METHOD_TLSv1_0_CLIENT === $options['crypto_method']) {
-                $conf[\CURLOPT_SSLVERSION] = \CURL_SSLVERSION_TLSv1_0;
-            } elseif (\STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT === $options['crypto_method']) {
-                $conf[\CURLOPT_SSLVERSION] = \CURL_SSLVERSION_TLSv1_1;
-            } elseif (\STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT === $options['crypto_method']) {
-                if (!self::supportsTls12()) {
-                    throw new \InvalidArgumentException('Invalid crypto_method request option: TLS 1.2 not supported by your version of cURL');
-                }
-                $conf[\CURLOPT_SSLVERSION] = \CURL_SSLVERSION_TLSv1_2;
-            } elseif (\defined('STREAM_CRYPTO_METHOD_TLSv1_3_CLIENT') && \STREAM_CRYPTO_METHOD_TLSv1_3_CLIENT === $options['crypto_method']) {
-                if (!self::supportsTls13()) {
-                    throw new \InvalidArgumentException('Invalid crypto_method request option: TLS 1.3 not supported by your version of cURL');
-                }
-                $conf[\CURLOPT_SSLVERSION] = \CURL_SSLVERSION_TLSv1_3;
-            } else {
-                throw new \InvalidArgumentException('Invalid crypto_method request option: unknown version provided');
-            }
-        }
-        if (isset($options['cert'])) {
-            $cert = $options['cert'];
-            if (\is_array($cert)) {
-                $conf[\CURLOPT_SSLCERTPASSWD] = $cert[1];
-                $cert = $cert[0];
-            }
-            if (!\file_exists($cert)) {
-                throw new \InvalidArgumentException("SSL certificate not found: {$cert}");
-            }
-            // OpenSSL (versions 0.9.3 and later) also support "P12" for PKCS#12-encoded files.
-            // see https://curl.se/libcurl/c/CURLOPT_SSLCERTTYPE.html
-            $ext = \pathinfo($cert, \PATHINFO_EXTENSION);
-            if (\preg_match('#^(der|p12)$#i', $ext)) {
-                $conf[\CURLOPT_SSLCERTTYPE] = \strtoupper($ext);
-            }
-            $conf[\CURLOPT_SSLCERT] = $cert;
-        }
-        if (isset($options['ssl_key'])) {
-            if (\is_array($options['ssl_key'])) {
-                if (\count($options['ssl_key']) === 2) {
-                    [$sslKey, $conf[\CURLOPT_SSLKEYPASSWD]] = $options['ssl_key'];
-                } else {
-                    [$sslKey] = $options['ssl_key'];
-                }
-            }
-            $sslKey = $sslKey ?? $options['ssl_key'];
-            if (!\file_exists($sslKey)) {
-                throw new \InvalidArgumentException("SSL private key not found: {$sslKey}");
-            }
-            $conf[\CURLOPT_SSLKEY] = $sslKey;
-        }
-        if (isset($options['progress'])) {
-            $progress = $options['progress'];
-            if (!\is_callable($progress)) {
-                throw new \InvalidArgumentException('progress client option must be callable');
-            }
-            $conf[\CURLOPT_NOPROGRESS] = \false;
-            $conf[\CURLOPT_PROGRESSFUNCTION] = static function ($resource, int $downloadSize, int $downloaded, int $uploadSize, int $uploaded) use($progress) {
-                $progress($downloadSize, $downloaded, $uploadSize, $uploaded);
-            };
-        }
-        if (!empty($options['debug'])) {
-            $conf[\CURLOPT_STDERR] = Utils::debugResource($options['debug']);
-            $conf[\CURLOPT_VERBOSE] = \true;
-        }
-    }
-    /**
-     * This function ensures that a response was set on a transaction. If one
-     * was not set, then the request is retried if possible. This error
-     * typically means you are sending a payload, curl encountered a
-     * "Connection died, retrying a fresh connect" error, tried to rewind the
-     * stream, and then encountered a "necessary data rewind wasn't possible"
-     * error, causing the request to be sent through curl_multi_info_read()
-     * without an error status.
-     *
-     * @param callable(RequestInterface, array): PromiseInterface $handler
-     */
-    private static function retryFailedRewind(callable $handler, EasyHandle $easy, array $ctx) : PromiseInterface
-    {
-        try {
-            // Only rewind if the body has been read from.
-            $body = $easy->request->getBody();
-            if ($body->tell() > 0) {
-                $body->rewind();
-            }
-        } catch (\RuntimeException $e) {
-            $ctx['error'] = 'The connection unexpectedly failed without ' . 'providing an error. The request would have been retried, ' . 'but attempting to rewind the request body failed. ' . 'Exception: ' . $e;
-            return self::createRejection($easy, $ctx);
-        }
-        // Retry no more than 3 times before giving up.
-        if (!isset($easy->options['_curl_retries'])) {
-            $easy->options['_curl_retries'] = 1;
-        } elseif ($easy->options['_curl_retries'] == 2) {
-            $ctx['error'] = 'The cURL request was retried 3 times ' . 'and did not succeed. The most likely reason for the failure ' . 'is that cURL was unable to rewind the body of the request ' . 'and subsequent retries resulted in the same error. Turn on ' . 'the debug option to see what went wrong. See ' . 'https://bugs.php.net/bug.php?id=47204 for more information.';
-            return self::createRejection($easy, $ctx);
-        } else {
-            ++$easy->options['_curl_retries'];
-        }
-        return $handler($easy->request, $easy->options);
-    }
-    private function createHeaderFn(EasyHandle $easy) : callable
-    {
-        if (isset($easy->options['on_headers'])) {
-            $onHeaders = $easy->options['on_headers'];
-            if (!\is_callable($onHeaders)) {
-                throw new \InvalidArgumentException('on_headers must be callable');
-            }
-        } else {
-            $onHeaders = null;
-        }
-        return static function ($ch, $h) use($onHeaders, $easy, &$startingResponse) {
-            $value = \trim($h);
-            if ($value === '') {
-                $startingResponse = \true;
-                try {
-                    $easy->createResponse();
-                } catch (\Exception $e) {
-                    $easy->createResponseException = $e;
-                    return -1;
-                }
-                if ($onHeaders !== null) {
-                    try {
-                        $onHeaders($easy->response);
-                    } catch (\Exception $e) {
-                        // Associate the exception with the handle and trigger
-                        // a curl header write error by returning 0.
-                        $easy->onHeadersException = $e;
-                        return -1;
-                    }
-                }
-            } elseif ($startingResponse) {
-                $startingResponse = \false;
-                $easy->headers = [$value];
-            } else {
-                $easy->headers[] = $value;
-            }
-            return \strlen($h);
-        };
-    }
-    public function __destruct()
-    {
-        foreach ($this->handles as $id => $handle) {
-            \curl_close($handle);
-            unset($this->handles[$id]);
-        }
-    }
+	public const CURL_VERSION_STR = 'curl_version';
+	/**
+	 * @deprecated
+	 */
+	public const LOW_CURL_VERSION_NUMBER = '7.21.2';
+	/**
+	 * @var resource[]|\CurlHandle[]
+	 */
+	private $handles = [];
+	/**
+	 * @var int Total number of idle handles to keep in cache
+	 */
+	private $maxHandles;
+	/**
+	 * @param int $maxHandles Maximum number of idle handles.
+	 */
+	public function __construct(int $maxHandles)
+	{
+		$this->maxHandles = $maxHandles;
+	}
+	public function create(RequestInterface $request, array $options) : EasyHandle
+	{
+		$protocolVersion = $request->getProtocolVersion();
+		if ('2' === $protocolVersion || '2.0' === $protocolVersion) {
+			if (!self::supportsHttp2()) {
+				throw new ConnectException('HTTP/2 is supported by the cURL handler, however libcurl is built without HTTP/2 support.', $request);
+			}
+		} elseif ('1.0' !== $protocolVersion && '1.1' !== $protocolVersion) {
+			throw new ConnectException(\sprintf('HTTP/%s is not supported by the cURL handler.', $protocolVersion), $request);
+		}
+		if (isset($options['curl']['body_as_string'])) {
+			$options['_body_as_string'] = $options['curl']['body_as_string'];
+			unset($options['curl']['body_as_string']);
+		}
+		$easy = new EasyHandle();
+		$easy->request = $request;
+		$easy->options = $options;
+		$conf = $this->getDefaultConf($easy);
+		$this->applyMethod($easy, $conf);
+		$this->applyHandlerOptions($easy, $conf);
+		$this->applyHeaders($easy, $conf);
+		unset($conf['_headers']);
+		// Add handler options from the request configuration options
+		if (isset($options['curl'])) {
+			$conf = \array_replace($conf, $options['curl']);
+		}
+		$conf[\CURLOPT_HEADERFUNCTION] = $this->createHeaderFn($easy);
+		$easy->handle = $this->handles ? \array_pop($this->handles) : \curl_init();
+		\curl_setopt_array($easy->handle, $conf);
+		return $easy;
+	}
+	private static function supportsHttp2() : bool
+	{
+		static $supportsHttp2 = null;
+		if (null === $supportsHttp2) {
+			$supportsHttp2 = self::supportsTls12() && \defined('CURL_VERSION_HTTP2') && \CURL_VERSION_HTTP2 & \curl_version()['features'];
+		}
+		return $supportsHttp2;
+	}
+	private static function supportsTls12() : bool
+	{
+		static $supportsTls12 = null;
+		if (null === $supportsTls12) {
+			$supportsTls12 = \CURL_SSLVERSION_TLSv1_2 & \curl_version()['features'];
+		}
+		return $supportsTls12;
+	}
+	private static function supportsTls13() : bool
+	{
+		static $supportsTls13 = null;
+		if (null === $supportsTls13) {
+			$supportsTls13 = \defined('CURL_SSLVERSION_TLSv1_3') && \CURL_SSLVERSION_TLSv1_3 & \curl_version()['features'];
+		}
+		return $supportsTls13;
+	}
+	public function release(EasyHandle $easy) : void
+	{
+		$resource = $easy->handle;
+		unset($easy->handle);
+		if (\count($this->handles) >= $this->maxHandles) {
+			\curl_close($resource);
+		} else {
+			// Remove all callback functions as they can hold onto references
+			// and are not cleaned up by curl_reset. Using curl_setopt_array
+			// does not work for some reason, so removing each one
+			// individually.
+			\curl_setopt($resource, \CURLOPT_HEADERFUNCTION, null);
+			\curl_setopt($resource, \CURLOPT_READFUNCTION, null);
+			\curl_setopt($resource, \CURLOPT_WRITEFUNCTION, null);
+			\curl_setopt($resource, \CURLOPT_PROGRESSFUNCTION, null);
+			\curl_reset($resource);
+			$this->handles[] = $resource;
+		}
+	}
+	/**
+	 * Completes a cURL transaction, either returning a response promise or a
+	 * rejected promise.
+	 *
+	 * @param callable(RequestInterface, array): PromiseInterface $handler
+	 * @param CurlFactoryInterface                                $factory Dictates how the handle is released
+	 */
+	public static function finish(callable $handler, EasyHandle $easy, CurlFactoryInterface $factory) : PromiseInterface
+	{
+		if (isset($easy->options['on_stats'])) {
+			self::invokeStats($easy);
+		}
+		if (!$easy->response || $easy->errno) {
+			return self::finishError($handler, $easy, $factory);
+		}
+		// Return the response if it is present and there is no error.
+		$factory->release($easy);
+		// Rewind the body of the response if possible.
+		$body = $easy->response->getBody();
+		if ($body->isSeekable()) {
+			$body->rewind();
+		}
+		return new FulfilledPromise($easy->response);
+	}
+	private static function invokeStats(EasyHandle $easy) : void
+	{
+		$curlStats = \curl_getinfo($easy->handle);
+		$curlStats['appconnect_time'] = \curl_getinfo($easy->handle, \CURLINFO_APPCONNECT_TIME);
+		$stats = new TransferStats($easy->request, $easy->response, $curlStats['total_time'], $easy->errno, $curlStats);
+		$easy->options['on_stats']($stats);
+	}
+	/**
+	 * @param callable(RequestInterface, array): PromiseInterface $handler
+	 */
+	private static function finishError(callable $handler, EasyHandle $easy, CurlFactoryInterface $factory) : PromiseInterface
+	{
+		// Get error information and release the handle to the factory.
+		$ctx = ['errno' => $easy->errno, 'error' => \curl_error($easy->handle), 'appconnect_time' => \curl_getinfo($easy->handle, \CURLINFO_APPCONNECT_TIME)] + \curl_getinfo($easy->handle);
+		$ctx[self::CURL_VERSION_STR] = self::getCurlVersion();
+		$factory->release($easy);
+		// Retry when nothing is present or when curl failed to rewind.
+		if (empty($easy->options['_err_message']) && (!$easy->errno || $easy->errno == 65)) {
+			return self::retryFailedRewind($handler, $easy, $ctx);
+		}
+		return self::createRejection($easy, $ctx);
+	}
+	private static function getCurlVersion() : string
+	{
+		static $curlVersion = null;
+		if (null === $curlVersion) {
+			$curlVersion = \curl_version()['version'];
+		}
+		return $curlVersion;
+	}
+	private static function createRejection(EasyHandle $easy, array $ctx) : PromiseInterface
+	{
+		static $connectionErrors = [\CURLE_OPERATION_TIMEOUTED => \true, \CURLE_COULDNT_RESOLVE_HOST => \true, \CURLE_COULDNT_CONNECT => \true, \CURLE_SSL_CONNECT_ERROR => \true, \CURLE_GOT_NOTHING => \true];
+		if ($easy->createResponseException) {
+			return P\Create::rejectionFor(new RequestException('An error was encountered while creating the response', $easy->request, $easy->response, $easy->createResponseException, $ctx));
+		}
+		// If an exception was encountered during the onHeaders event, then
+		// return a rejected promise that wraps that exception.
+		if ($easy->onHeadersException) {
+			return P\Create::rejectionFor(new RequestException('An error was encountered during the on_headers event', $easy->request, $easy->response, $easy->onHeadersException, $ctx));
+		}
+		$uri = $easy->request->getUri();
+		$sanitizedError = self::sanitizeCurlError($ctx['error'] ?? '', $uri);
+		$message = \sprintf('cURL error %s: %s (%s)', $ctx['errno'], $sanitizedError, 'see https://curl.haxx.se/libcurl/c/libcurl-errors.html');
+		if ('' !== $sanitizedError) {
+			$redactedUriString = \OCA\FullTextSearch_Elasticsearch\Vendor\GuzzleHttp\Psr7\Utils::redactUserInfo($uri)->__toString();
+			if ($redactedUriString !== '' && \false === \strpos($sanitizedError, $redactedUriString)) {
+				$message .= \sprintf(' for %s', $redactedUriString);
+			}
+		}
+		// Create a connection exception if it was a specific error code.
+		$error = isset($connectionErrors[$easy->errno]) ? new ConnectException($message, $easy->request, null, $ctx) : new RequestException($message, $easy->request, $easy->response, null, $ctx);
+		return P\Create::rejectionFor($error);
+	}
+	private static function sanitizeCurlError(string $error, UriInterface $uri) : string
+	{
+		if ('' === $error) {
+			return $error;
+		}
+		$baseUri = $uri->withQuery('')->withFragment('');
+		$baseUriString = $baseUri->__toString();
+		if ('' === $baseUriString) {
+			return $error;
+		}
+		$redactedUriString = \OCA\FullTextSearch_Elasticsearch\Vendor\GuzzleHttp\Psr7\Utils::redactUserInfo($baseUri)->__toString();
+		return \str_replace($baseUriString, $redactedUriString, $error);
+	}
+	/**
+	 * @return array<int|string, mixed>
+	 */
+	private function getDefaultConf(EasyHandle $easy) : array
+	{
+		$conf = ['_headers' => $easy->request->getHeaders(), \CURLOPT_CUSTOMREQUEST => $easy->request->getMethod(), \CURLOPT_URL => (string) $easy->request->getUri()->withFragment(''), \CURLOPT_RETURNTRANSFER => \false, \CURLOPT_HEADER => \false, \CURLOPT_CONNECTTIMEOUT => 300];
+		if (\defined('CURLOPT_PROTOCOLS')) {
+			$conf[\CURLOPT_PROTOCOLS] = \CURLPROTO_HTTP | \CURLPROTO_HTTPS;
+		}
+		$version = $easy->request->getProtocolVersion();
+		if ('2' === $version || '2.0' === $version) {
+			$conf[\CURLOPT_HTTP_VERSION] = \CURL_HTTP_VERSION_2_0;
+		} elseif ('1.1' === $version) {
+			$conf[\CURLOPT_HTTP_VERSION] = \CURL_HTTP_VERSION_1_1;
+		} else {
+			$conf[\CURLOPT_HTTP_VERSION] = \CURL_HTTP_VERSION_1_0;
+		}
+		return $conf;
+	}
+	private function applyMethod(EasyHandle $easy, array &$conf) : void
+	{
+		$body = $easy->request->getBody();
+		$size = $body->getSize();
+		if ($size === null || $size > 0) {
+			$this->applyBody($easy->request, $easy->options, $conf);
+			return;
+		}
+		$method = $easy->request->getMethod();
+		if ($method === 'PUT' || $method === 'POST') {
+			// See https://datatracker.ietf.org/doc/html/rfc7230#section-3.3.2
+			if (!$easy->request->hasHeader('Content-Length')) {
+				$conf[\CURLOPT_HTTPHEADER][] = 'Content-Length: 0';
+			}
+		} elseif ($method === 'HEAD') {
+			$conf[\CURLOPT_NOBODY] = \true;
+			unset($conf[\CURLOPT_WRITEFUNCTION], $conf[\CURLOPT_READFUNCTION], $conf[\CURLOPT_FILE], $conf[\CURLOPT_INFILE]);
+		}
+	}
+	private function applyBody(RequestInterface $request, array $options, array &$conf) : void
+	{
+		$size = $request->hasHeader('Content-Length') ? (int) $request->getHeaderLine('Content-Length') : null;
+		// Send the body as a string if the size is less than 1MB OR if the
+		// [curl][body_as_string] request value is set.
+		if ($size !== null && $size < 1000000 || !empty($options['_body_as_string'])) {
+			$conf[\CURLOPT_POSTFIELDS] = (string) $request->getBody();
+			// Don't duplicate the Content-Length header
+			$this->removeHeader('Content-Length', $conf);
+			$this->removeHeader('Transfer-Encoding', $conf);
+		} else {
+			$conf[\CURLOPT_UPLOAD] = \true;
+			if ($size !== null) {
+				$conf[\CURLOPT_INFILESIZE] = $size;
+				$this->removeHeader('Content-Length', $conf);
+			}
+			$body = $request->getBody();
+			if ($body->isSeekable()) {
+				$body->rewind();
+			}
+			$conf[\CURLOPT_READFUNCTION] = static function ($ch, $fd, $length) use($body) {
+				return $body->read($length);
+			};
+		}
+		// If the Expect header is not present, prevent curl from adding it
+		if (!$request->hasHeader('Expect')) {
+			$conf[\CURLOPT_HTTPHEADER][] = 'Expect:';
+		}
+		// cURL sometimes adds a content-type by default. Prevent this.
+		if (!$request->hasHeader('Content-Type')) {
+			$conf[\CURLOPT_HTTPHEADER][] = 'Content-Type:';
+		}
+	}
+	private function applyHeaders(EasyHandle $easy, array &$conf) : void
+	{
+		foreach ($conf['_headers'] as $name => $values) {
+			foreach ($values as $value) {
+				$value = (string) $value;
+				if ($value === '') {
+					// cURL requires a special format for empty headers.
+					// See https://github.com/guzzle/guzzle/issues/1882 for more details.
+					$conf[\CURLOPT_HTTPHEADER][] = "{$name};";
+				} else {
+					$conf[\CURLOPT_HTTPHEADER][] = "{$name}: {$value}";
+				}
+			}
+		}
+		// Remove the Accept header if one was not set
+		if (!$easy->request->hasHeader('Accept')) {
+			$conf[\CURLOPT_HTTPHEADER][] = 'Accept:';
+		}
+	}
+	/**
+	 * Remove a header from the options array.
+	 *
+	 * @param string $name    Case-insensitive header to remove
+	 * @param array  $options Array of options to modify
+	 */
+	private function removeHeader(string $name, array &$options) : void
+	{
+		foreach (\array_keys($options['_headers']) as $key) {
+			if (!\strcasecmp($key, $name)) {
+				unset($options['_headers'][$key]);
+				return;
+			}
+		}
+	}
+	private function applyHandlerOptions(EasyHandle $easy, array &$conf) : void
+	{
+		$options = $easy->options;
+		if (isset($options['verify'])) {
+			if ($options['verify'] === \false) {
+				unset($conf[\CURLOPT_CAINFO]);
+				$conf[\CURLOPT_SSL_VERIFYHOST] = 0;
+				$conf[\CURLOPT_SSL_VERIFYPEER] = \false;
+			} else {
+				$conf[\CURLOPT_SSL_VERIFYHOST] = 2;
+				$conf[\CURLOPT_SSL_VERIFYPEER] = \true;
+				if (\is_string($options['verify'])) {
+					// Throw an error if the file/folder/link path is not valid or doesn't exist.
+					if (!\file_exists($options['verify'])) {
+						throw new \InvalidArgumentException("SSL CA bundle not found: {$options['verify']}");
+					}
+					// If it's a directory or a link to a directory use CURLOPT_CAPATH.
+					// If not, it's probably a file, or a link to a file, so use CURLOPT_CAINFO.
+					if (\is_dir($options['verify']) || \is_link($options['verify']) === \true && ($verifyLink = \readlink($options['verify'])) !== \false && \is_dir($verifyLink)) {
+						$conf[\CURLOPT_CAPATH] = $options['verify'];
+					} else {
+						$conf[\CURLOPT_CAINFO] = $options['verify'];
+					}
+				}
+			}
+		}
+		if (!isset($options['curl'][\CURLOPT_ENCODING]) && !empty($options['decode_content'])) {
+			$accept = $easy->request->getHeaderLine('Accept-Encoding');
+			if ($accept) {
+				$conf[\CURLOPT_ENCODING] = $accept;
+			} else {
+				// The empty string enables all available decoders and implicitly
+				// sets a matching 'Accept-Encoding' header.
+				$conf[\CURLOPT_ENCODING] = '';
+				// But as the user did not specify any encoding preference,
+				// let's leave it up to server by preventing curl from sending
+				// the header, which will be interpreted as 'Accept-Encoding: *'.
+				// https://www.rfc-editor.org/rfc/rfc9110#field.accept-encoding
+				$conf[\CURLOPT_HTTPHEADER][] = 'Accept-Encoding:';
+			}
+		}
+		if (!isset($options['sink'])) {
+			// Use a default temp stream if no sink was set.
+			$options['sink'] = \OCA\FullTextSearch_Elasticsearch\Vendor\GuzzleHttp\Psr7\Utils::tryFopen('php://temp', 'w+');
+		}
+		$sink = $options['sink'];
+		if (!\is_string($sink)) {
+			$sink = \OCA\FullTextSearch_Elasticsearch\Vendor\GuzzleHttp\Psr7\Utils::streamFor($sink);
+		} elseif (!\is_dir(\dirname($sink))) {
+			// Ensure that the directory exists before failing in curl.
+			throw new \RuntimeException(\sprintf('Directory %s does not exist for sink value of %s', \dirname($sink), $sink));
+		} else {
+			$sink = new LazyOpenStream($sink, 'w+');
+		}
+		$easy->sink = $sink;
+		$conf[\CURLOPT_WRITEFUNCTION] = static function ($ch, $write) use($sink) : int {
+			return $sink->write($write);
+		};
+		$timeoutRequiresNoSignal = \false;
+		if (isset($options['timeout'])) {
+			$timeoutRequiresNoSignal |= $options['timeout'] < 1;
+			$conf[\CURLOPT_TIMEOUT_MS] = $options['timeout'] * 1000;
+		}
+		// CURL default value is CURL_IPRESOLVE_WHATEVER
+		if (isset($options['force_ip_resolve'])) {
+			if ('v4' === $options['force_ip_resolve']) {
+				$conf[\CURLOPT_IPRESOLVE] = \CURL_IPRESOLVE_V4;
+			} elseif ('v6' === $options['force_ip_resolve']) {
+				$conf[\CURLOPT_IPRESOLVE] = \CURL_IPRESOLVE_V6;
+			}
+		}
+		if (isset($options['connect_timeout'])) {
+			$timeoutRequiresNoSignal |= $options['connect_timeout'] < 1;
+			$conf[\CURLOPT_CONNECTTIMEOUT_MS] = $options['connect_timeout'] * 1000;
+		}
+		if ($timeoutRequiresNoSignal && \strtoupper(\substr(\PHP_OS, 0, 3)) !== 'WIN') {
+			$conf[\CURLOPT_NOSIGNAL] = \true;
+		}
+		if (isset($options['proxy'])) {
+			if (!\is_array($options['proxy'])) {
+				$conf[\CURLOPT_PROXY] = $options['proxy'];
+			} else {
+				$scheme = $easy->request->getUri()->getScheme();
+				if (isset($options['proxy'][$scheme])) {
+					$host = $easy->request->getUri()->getHost();
+					if (isset($options['proxy']['no']) && Utils::isHostInNoProxy($host, $options['proxy']['no'])) {
+						unset($conf[\CURLOPT_PROXY]);
+					} else {
+						$conf[\CURLOPT_PROXY] = $options['proxy'][$scheme];
+					}
+				}
+			}
+		}
+		if (isset($options['crypto_method'])) {
+			$protocolVersion = $easy->request->getProtocolVersion();
+			// If HTTP/2, upgrade TLS 1.0 and 1.1 to 1.2
+			if ('2' === $protocolVersion || '2.0' === $protocolVersion) {
+				if (\STREAM_CRYPTO_METHOD_TLSv1_0_CLIENT === $options['crypto_method'] || \STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT === $options['crypto_method'] || \STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT === $options['crypto_method']) {
+					$conf[\CURLOPT_SSLVERSION] = \CURL_SSLVERSION_TLSv1_2;
+				} elseif (\defined('STREAM_CRYPTO_METHOD_TLSv1_3_CLIENT') && \STREAM_CRYPTO_METHOD_TLSv1_3_CLIENT === $options['crypto_method']) {
+					if (!self::supportsTls13()) {
+						throw new \InvalidArgumentException('Invalid crypto_method request option: TLS 1.3 not supported by your version of cURL');
+					}
+					$conf[\CURLOPT_SSLVERSION] = \CURL_SSLVERSION_TLSv1_3;
+				} else {
+					throw new \InvalidArgumentException('Invalid crypto_method request option: unknown version provided');
+				}
+			} elseif (\STREAM_CRYPTO_METHOD_TLSv1_0_CLIENT === $options['crypto_method']) {
+				$conf[\CURLOPT_SSLVERSION] = \CURL_SSLVERSION_TLSv1_0;
+			} elseif (\STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT === $options['crypto_method']) {
+				$conf[\CURLOPT_SSLVERSION] = \CURL_SSLVERSION_TLSv1_1;
+			} elseif (\STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT === $options['crypto_method']) {
+				if (!self::supportsTls12()) {
+					throw new \InvalidArgumentException('Invalid crypto_method request option: TLS 1.2 not supported by your version of cURL');
+				}
+				$conf[\CURLOPT_SSLVERSION] = \CURL_SSLVERSION_TLSv1_2;
+			} elseif (\defined('STREAM_CRYPTO_METHOD_TLSv1_3_CLIENT') && \STREAM_CRYPTO_METHOD_TLSv1_3_CLIENT === $options['crypto_method']) {
+				if (!self::supportsTls13()) {
+					throw new \InvalidArgumentException('Invalid crypto_method request option: TLS 1.3 not supported by your version of cURL');
+				}
+				$conf[\CURLOPT_SSLVERSION] = \CURL_SSLVERSION_TLSv1_3;
+			} else {
+				throw new \InvalidArgumentException('Invalid crypto_method request option: unknown version provided');
+			}
+		}
+		if (isset($options['cert'])) {
+			$cert = $options['cert'];
+			if (\is_array($cert)) {
+				$conf[\CURLOPT_SSLCERTPASSWD] = $cert[1];
+				$cert = $cert[0];
+			}
+			if (!\file_exists($cert)) {
+				throw new \InvalidArgumentException("SSL certificate not found: {$cert}");
+			}
+			// OpenSSL (versions 0.9.3 and later) also support "P12" for PKCS#12-encoded files.
+			// see https://curl.se/libcurl/c/CURLOPT_SSLCERTTYPE.html
+			$ext = \pathinfo($cert, \PATHINFO_EXTENSION);
+			if (\preg_match('#^(der|p12)$#i', $ext)) {
+				$conf[\CURLOPT_SSLCERTTYPE] = \strtoupper($ext);
+			}
+			$conf[\CURLOPT_SSLCERT] = $cert;
+		}
+		if (isset($options['ssl_key'])) {
+			if (\is_array($options['ssl_key'])) {
+				if (\count($options['ssl_key']) === 2) {
+					[$sslKey, $conf[\CURLOPT_SSLKEYPASSWD]] = $options['ssl_key'];
+				} else {
+					[$sslKey] = $options['ssl_key'];
+				}
+			}
+			$sslKey = $sslKey ?? $options['ssl_key'];
+			if (!\file_exists($sslKey)) {
+				throw new \InvalidArgumentException("SSL private key not found: {$sslKey}");
+			}
+			$conf[\CURLOPT_SSLKEY] = $sslKey;
+		}
+		if (isset($options['progress'])) {
+			$progress = $options['progress'];
+			if (!\is_callable($progress)) {
+				throw new \InvalidArgumentException('progress client option must be callable');
+			}
+			$conf[\CURLOPT_NOPROGRESS] = \false;
+			$conf[\CURLOPT_PROGRESSFUNCTION] = static function ($resource, int $downloadSize, int $downloaded, int $uploadSize, int $uploaded) use($progress) {
+				$progress($downloadSize, $downloaded, $uploadSize, $uploaded);
+			};
+		}
+		if (!empty($options['debug'])) {
+			$conf[\CURLOPT_STDERR] = Utils::debugResource($options['debug']);
+			$conf[\CURLOPT_VERBOSE] = \true;
+		}
+	}
+	/**
+	 * This function ensures that a response was set on a transaction. If one
+	 * was not set, then the request is retried if possible. This error
+	 * typically means you are sending a payload, curl encountered a
+	 * "Connection died, retrying a fresh connect" error, tried to rewind the
+	 * stream, and then encountered a "necessary data rewind wasn't possible"
+	 * error, causing the request to be sent through curl_multi_info_read()
+	 * without an error status.
+	 *
+	 * @param callable(RequestInterface, array): PromiseInterface $handler
+	 */
+	private static function retryFailedRewind(callable $handler, EasyHandle $easy, array $ctx) : PromiseInterface
+	{
+		try {
+			// Only rewind if the body has been read from.
+			$body = $easy->request->getBody();
+			if ($body->tell() > 0) {
+				$body->rewind();
+			}
+		} catch (\RuntimeException $e) {
+			$ctx['error'] = 'The connection unexpectedly failed without ' . 'providing an error. The request would have been retried, ' . 'but attempting to rewind the request body failed. ' . 'Exception: ' . $e;
+			return self::createRejection($easy, $ctx);
+		}
+		// Retry no more than 3 times before giving up.
+		if (!isset($easy->options['_curl_retries'])) {
+			$easy->options['_curl_retries'] = 1;
+		} elseif ($easy->options['_curl_retries'] == 2) {
+			$ctx['error'] = 'The cURL request was retried 3 times ' . 'and did not succeed. The most likely reason for the failure ' . 'is that cURL was unable to rewind the body of the request ' . 'and subsequent retries resulted in the same error. Turn on ' . 'the debug option to see what went wrong. See ' . 'https://bugs.php.net/bug.php?id=47204 for more information.';
+			return self::createRejection($easy, $ctx);
+		} else {
+			++$easy->options['_curl_retries'];
+		}
+		return $handler($easy->request, $easy->options);
+	}
+	private function createHeaderFn(EasyHandle $easy) : callable
+	{
+		if (isset($easy->options['on_headers'])) {
+			$onHeaders = $easy->options['on_headers'];
+			if (!\is_callable($onHeaders)) {
+				throw new \InvalidArgumentException('on_headers must be callable');
+			}
+		} else {
+			$onHeaders = null;
+		}
+		return static function ($ch, $h) use($onHeaders, $easy, &$startingResponse) {
+			$value = \trim($h);
+			if ($value === '') {
+				$startingResponse = \true;
+				try {
+					$easy->createResponse();
+				} catch (\Exception $e) {
+					$easy->createResponseException = $e;
+					return -1;
+				}
+				if ($onHeaders !== null) {
+					try {
+						$onHeaders($easy->response);
+					} catch (\Exception $e) {
+						// Associate the exception with the handle and trigger
+						// a curl header write error by returning 0.
+						$easy->onHeadersException = $e;
+						return -1;
+					}
+				}
+			} elseif ($startingResponse) {
+				$startingResponse = \false;
+				$easy->headers = [$value];
+			} else {
+				$easy->headers[] = $value;
+			}
+			return \strlen($h);
+		};
+	}
+	public function __destruct()
+	{
+		foreach ($this->handles as $id => $handle) {
+			\curl_close($handle);
+			unset($this->handles[$id]);
+		}
+	}
 }

Spacing +10 added lines, -10 removed lines

@@ -209,7 +209,7 @@ 
      */
     private function getDefaultConf(EasyHandle $easy) : array
     {
-        $conf = ['_headers' => $easy->request->getHeaders(), \CURLOPT_CUSTOMREQUEST => $easy->request->getMethod(), \CURLOPT_URL => (string) $easy->request->getUri()->withFragment(''), \CURLOPT_RETURNTRANSFER => \false, \CURLOPT_HEADER => \false, \CURLOPT_CONNECTTIMEOUT => 300];
+        $conf = ['_headers' => $easy->request->getHeaders(), \CURLOPT_CUSTOMREQUEST => $easy->request->getMethod(), \CURLOPT_URL => (string)$easy->request->getUri()->withFragment(''), \CURLOPT_RETURNTRANSFER => \false, \CURLOPT_HEADER => \false, \CURLOPT_CONNECTTIMEOUT => 300];
         if (\defined('CURLOPT_PROTOCOLS')) {
             $conf[\CURLOPT_PROTOCOLS] = \CURLPROTO_HTTP | \CURLPROTO_HTTPS;
         }
@@ -244,11 +244,11 @@ 
     }
     private function applyBody(RequestInterface $request, array $options, array &$conf) : void
     {
-        $size = $request->hasHeader('Content-Length') ? (int) $request->getHeaderLine('Content-Length') : null;
+        $size = $request->hasHeader('Content-Length') ? (int)$request->getHeaderLine('Content-Length') : null;
         // Send the body as a string if the size is less than 1MB OR if the
         // [curl][body_as_string] request value is set.
         if ($size !== null && $size < 1000000 || !empty($options['_body_as_string'])) {
-            $conf[\CURLOPT_POSTFIELDS] = (string) $request->getBody();
+            $conf[\CURLOPT_POSTFIELDS] = (string)$request->getBody();
             // Don't duplicate the Content-Length header
             $this->removeHeader('Content-Length', $conf);
             $this->removeHeader('Transfer-Encoding', $conf);
@@ -262,7 +262,7 @@ 
             if ($body->isSeekable()) {
                 $body->rewind();
             }
-            $conf[\CURLOPT_READFUNCTION] = static function ($ch, $fd, $length) use($body) {
+            $conf[\CURLOPT_READFUNCTION] = static function($ch, $fd, $length) use($body) {
                 return $body->read($length);
             };
         }
@@ -279,7 +279,7 @@ 
     {
         foreach ($conf['_headers'] as $name => $values) {
             foreach ($values as $value) {
-                $value = (string) $value;
+                $value = (string)$value;
                 if ($value === '') {
                     // cURL requires a special format for empty headers.
                     // See https://github.com/guzzle/guzzle/issues/1882 for more details.
@@ -364,7 +364,7 @@ 
             $sink = new LazyOpenStream($sink, 'w+');
         }
         $easy->sink = $sink;
-        $conf[\CURLOPT_WRITEFUNCTION] = static function ($ch, $write) use($sink) : int {
+        $conf[\CURLOPT_WRITEFUNCTION] = static function($ch, $write) use($sink) : int {
             return $sink->write($write);
         };
         $timeoutRequiresNoSignal = \false;
@@ -471,7 +471,7 @@ 
                 throw new \InvalidArgumentException('progress client option must be callable');
             }
             $conf[\CURLOPT_NOPROGRESS] = \false;
-            $conf[\CURLOPT_PROGRESSFUNCTION] = static function ($resource, int $downloadSize, int $downloaded, int $uploadSize, int $uploaded) use($progress) {
+            $conf[\CURLOPT_PROGRESSFUNCTION] = static function($resource, int $downloadSize, int $downloaded, int $uploadSize, int $uploaded) use($progress) {
                 $progress($downloadSize, $downloaded, $uploadSize, $uploaded);
             };
         }
@@ -500,14 +500,14 @@ 
                 $body->rewind();
             }
         } catch (\RuntimeException $e) {
-            $ctx['error'] = 'The connection unexpectedly failed without ' . 'providing an error. The request would have been retried, ' . 'but attempting to rewind the request body failed. ' . 'Exception: ' . $e;
+            $ctx['error'] = 'The connection unexpectedly failed without '.'providing an error. The request would have been retried, '.'but attempting to rewind the request body failed. '.'Exception: '.$e;
             return self::createRejection($easy, $ctx);
         }
         // Retry no more than 3 times before giving up.
         if (!isset($easy->options['_curl_retries'])) {
             $easy->options['_curl_retries'] = 1;
         } elseif ($easy->options['_curl_retries'] == 2) {
-            $ctx['error'] = 'The cURL request was retried 3 times ' . 'and did not succeed. The most likely reason for the failure ' . 'is that cURL was unable to rewind the body of the request ' . 'and subsequent retries resulted in the same error. Turn on ' . 'the debug option to see what went wrong. See ' . 'https://bugs.php.net/bug.php?id=47204 for more information.';
+            $ctx['error'] = 'The cURL request was retried 3 times '.'and did not succeed. The most likely reason for the failure '.'is that cURL was unable to rewind the body of the request '.'and subsequent retries resulted in the same error. Turn on '.'the debug option to see what went wrong. See '.'https://bugs.php.net/bug.php?id=47204 for more information.';
             return self::createRejection($easy, $ctx);
         } else {
             ++$easy->options['_curl_retries'];
@@ -524,7 +524,7 @@ 
         } else {
             $onHeaders = null;
         }
-        return static function ($ch, $h) use($onHeaders, $easy, &$startingResponse) {
+        return static function($ch, $h) use($onHeaders, $easy, &$startingResponse) {
             $value = \trim($h);
             if ($value === '') {
                 $startingResponse = \true;

lib/Vendor/GuzzleHttp/Promise/Coroutine.php

Indentation +97 added lines, -97 removed lines

@@ -43,101 +43,101 @@
  */
 final class Coroutine implements PromiseInterface
 {
-    /**
-     * @var PromiseInterface|null
-     */
-    private $currentPromise;
-    /**
-     * @var Generator
-     */
-    private $generator;
-    /**
-     * @var Promise
-     */
-    private $result;
-    public function __construct(callable $generatorFn)
-    {
-        $this->generator = $generatorFn();
-        $this->result = new Promise(function () : void {
-            while (isset($this->currentPromise)) {
-                $this->currentPromise->wait();
-            }
-        });
-        try {
-            $this->nextCoroutine($this->generator->current());
-        } catch (Throwable $throwable) {
-            $this->result->reject($throwable);
-        }
-    }
-    /**
-     * Create a new coroutine.
-     */
-    public static function of(callable $generatorFn) : self
-    {
-        return new self($generatorFn);
-    }
-    public function then(?callable $onFulfilled = null, ?callable $onRejected = null) : PromiseInterface
-    {
-        return $this->result->then($onFulfilled, $onRejected);
-    }
-    public function otherwise(callable $onRejected) : PromiseInterface
-    {
-        return $this->result->otherwise($onRejected);
-    }
-    public function wait(bool $unwrap = \true)
-    {
-        return $this->result->wait($unwrap);
-    }
-    public function getState() : string
-    {
-        return $this->result->getState();
-    }
-    public function resolve($value) : void
-    {
-        $this->result->resolve($value);
-    }
-    public function reject($reason) : void
-    {
-        $this->result->reject($reason);
-    }
-    public function cancel() : void
-    {
-        $this->currentPromise->cancel();
-        $this->result->cancel();
-    }
-    private function nextCoroutine($yielded) : void
-    {
-        $this->currentPromise = Create::promiseFor($yielded)->then([$this, '_handleSuccess'], [$this, '_handleFailure']);
-    }
-    /**
-     * @internal
-     */
-    public function _handleSuccess($value) : void
-    {
-        unset($this->currentPromise);
-        try {
-            $next = $this->generator->send($value);
-            if ($this->generator->valid()) {
-                $this->nextCoroutine($next);
-            } else {
-                $this->result->resolve($value);
-            }
-        } catch (Throwable $throwable) {
-            $this->result->reject($throwable);
-        }
-    }
-    /**
-     * @internal
-     */
-    public function _handleFailure($reason) : void
-    {
-        unset($this->currentPromise);
-        try {
-            $nextYield = $this->generator->throw(Create::exceptionFor($reason));
-            // The throw was caught, so keep iterating on the coroutine
-            $this->nextCoroutine($nextYield);
-        } catch (Throwable $throwable) {
-            $this->result->reject($throwable);
-        }
-    }
+	/**
+	 * @var PromiseInterface|null
+	 */
+	private $currentPromise;
+	/**
+	 * @var Generator
+	 */
+	private $generator;
+	/**
+	 * @var Promise
+	 */
+	private $result;
+	public function __construct(callable $generatorFn)
+	{
+		$this->generator = $generatorFn();
+		$this->result = new Promise(function () : void {
+			while (isset($this->currentPromise)) {
+				$this->currentPromise->wait();
+			}
+		});
+		try {
+			$this->nextCoroutine($this->generator->current());
+		} catch (Throwable $throwable) {
+			$this->result->reject($throwable);
+		}
+	}
+	/**
+	 * Create a new coroutine.
+	 */
+	public static function of(callable $generatorFn) : self
+	{
+		return new self($generatorFn);
+	}
+	public function then(?callable $onFulfilled = null, ?callable $onRejected = null) : PromiseInterface
+	{
+		return $this->result->then($onFulfilled, $onRejected);
+	}
+	public function otherwise(callable $onRejected) : PromiseInterface
+	{
+		return $this->result->otherwise($onRejected);
+	}
+	public function wait(bool $unwrap = \true)
+	{
+		return $this->result->wait($unwrap);
+	}
+	public function getState() : string
+	{
+		return $this->result->getState();
+	}
+	public function resolve($value) : void
+	{
+		$this->result->resolve($value);
+	}
+	public function reject($reason) : void
+	{
+		$this->result->reject($reason);
+	}
+	public function cancel() : void
+	{
+		$this->currentPromise->cancel();
+		$this->result->cancel();
+	}
+	private function nextCoroutine($yielded) : void
+	{
+		$this->currentPromise = Create::promiseFor($yielded)->then([$this, '_handleSuccess'], [$this, '_handleFailure']);
+	}
+	/**
+	 * @internal
+	 */
+	public function _handleSuccess($value) : void
+	{
+		unset($this->currentPromise);
+		try {
+			$next = $this->generator->send($value);
+			if ($this->generator->valid()) {
+				$this->nextCoroutine($next);
+			} else {
+				$this->result->resolve($value);
+			}
+		} catch (Throwable $throwable) {
+			$this->result->reject($throwable);
+		}
+	}
+	/**
+	 * @internal
+	 */
+	public function _handleFailure($reason) : void
+	{
+		unset($this->currentPromise);
+		try {
+			$nextYield = $this->generator->throw(Create::exceptionFor($reason));
+			// The throw was caught, so keep iterating on the coroutine
+			$this->nextCoroutine($nextYield);
+		} catch (Throwable $throwable) {
+			$this->result->reject($throwable);
+		}
+	}
 }

lib/Vendor/GuzzleHttp/Promise/Utils.php

Indentation +211 added lines, -211 removed lines

@@ -5,215 +5,215 @@
 
 final class Utils
 {
-    /**
-     * Get the global task queue used for promise resolution.
-     *
-     * This task queue MUST be run in an event loop in order for promises to be
-     * settled asynchronously. It will be automatically run when synchronously
-     * waiting on a promise.
-     *
-     * <code>
-     * while ($eventLoop->isRunning()) {
-     *     GuzzleHttp\Promise\Utils::queue()->run();
-     * }
-     * </code>
-     *
-     * @param TaskQueueInterface|null $assign Optionally specify a new queue instance.
-     */
-    public static function queue(?TaskQueueInterface $assign = null) : TaskQueueInterface
-    {
-        static $queue;
-        if ($assign) {
-            $queue = $assign;
-        } elseif (!$queue) {
-            $queue = new TaskQueue();
-        }
-        return $queue;
-    }
-    /**
-     * Adds a function to run in the task queue when it is next `run()` and
-     * returns a promise that is fulfilled or rejected with the result.
-     *
-     * @param callable $task Task function to run.
-     */
-    public static function task(callable $task) : PromiseInterface
-    {
-        $queue = self::queue();
-        $promise = new Promise([$queue, 'run']);
-        $queue->add(function () use($task, $promise) : void {
-            try {
-                if (Is::pending($promise)) {
-                    $promise->resolve($task());
-                }
-            } catch (\Throwable $e) {
-                $promise->reject($e);
-            }
-        });
-        return $promise;
-    }
-    /**
-     * Synchronously waits on a promise to resolve and returns an inspection
-     * state array.
-     *
-     * Returns a state associative array containing a "state" key mapping to a
-     * valid promise state. If the state of the promise is "fulfilled", the
-     * array will contain a "value" key mapping to the fulfilled value of the
-     * promise. If the promise is rejected, the array will contain a "reason"
-     * key mapping to the rejection reason of the promise.
-     *
-     * @param PromiseInterface $promise Promise or value.
-     */
-    public static function inspect(PromiseInterface $promise) : array
-    {
-        try {
-            return ['state' => PromiseInterface::FULFILLED, 'value' => $promise->wait()];
-        } catch (RejectionException $e) {
-            return ['state' => PromiseInterface::REJECTED, 'reason' => $e->getReason()];
-        } catch (\Throwable $e) {
-            return ['state' => PromiseInterface::REJECTED, 'reason' => $e];
-        }
-    }
-    /**
-     * Waits on all of the provided promises, but does not unwrap rejected
-     * promises as thrown exception.
-     *
-     * Returns an array of inspection state arrays.
-     *
-     * @see inspect for the inspection state array format.
-     *
-     * @param PromiseInterface[] $promises Traversable of promises to wait upon.
-     */
-    public static function inspectAll($promises) : array
-    {
-        $results = [];
-        foreach ($promises as $key => $promise) {
-            $results[$key] = self::inspect($promise);
-        }
-        return $results;
-    }
-    /**
-     * Waits on all of the provided promises and returns the fulfilled values.
-     *
-     * Returns an array that contains the value of each promise (in the same
-     * order the promises were provided). An exception is thrown if any of the
-     * promises are rejected.
-     *
-     * @param iterable<PromiseInterface> $promises Iterable of PromiseInterface objects to wait on.
-     *
-     * @throws \Throwable on error
-     */
-    public static function unwrap($promises) : array
-    {
-        $results = [];
-        foreach ($promises as $key => $promise) {
-            $results[$key] = $promise->wait();
-        }
-        return $results;
-    }
-    /**
-     * Given an array of promises, return a promise that is fulfilled when all
-     * the items in the array are fulfilled.
-     *
-     * The promise's fulfillment value is an array with fulfillment values at
-     * respective positions to the original array. If any promise in the array
-     * rejects, the returned promise is rejected with the rejection reason.
-     *
-     * @param mixed $promises  Promises or values.
-     * @param bool  $recursive If true, resolves new promises that might have been added to the stack during its own resolution.
-     */
-    public static function all($promises, bool $recursive = \false) : PromiseInterface
-    {
-        $results = [];
-        $promise = Each::of($promises, function ($value, $idx) use(&$results) : void {
-            $results[$idx] = $value;
-        }, function ($reason, $idx, Promise $aggregate) : void {
-            if (Is::pending($aggregate)) {
-                $aggregate->reject($reason);
-            }
-        })->then(function () use(&$results) {
-            \ksort($results);
-            return $results;
-        });
-        if (\true === $recursive) {
-            $promise = $promise->then(function ($results) use($recursive, &$promises) {
-                foreach ($promises as $promise) {
-                    if (Is::pending($promise)) {
-                        return self::all($promises, $recursive);
-                    }
-                }
-                return $results;
-            });
-        }
-        return $promise;
-    }
-    /**
-     * Initiate a competitive race between multiple promises or values (values
-     * will become immediately fulfilled promises).
-     *
-     * When count amount of promises have been fulfilled, the returned promise
-     * is fulfilled with an array that contains the fulfillment values of the
-     * winners in order of resolution.
-     *
-     * This promise is rejected with a {@see AggregateException} if the number
-     * of fulfilled promises is less than the desired $count.
-     *
-     * @param int   $count    Total number of promises.
-     * @param mixed $promises Promises or values.
-     */
-    public static function some(int $count, $promises) : PromiseInterface
-    {
-        $results = [];
-        $rejections = [];
-        return Each::of($promises, function ($value, $idx, PromiseInterface $p) use(&$results, $count) : void {
-            if (Is::settled($p)) {
-                return;
-            }
-            $results[$idx] = $value;
-            if (\count($results) >= $count) {
-                $p->resolve(null);
-            }
-        }, function ($reason) use(&$rejections) : void {
-            $rejections[] = $reason;
-        })->then(function () use(&$results, &$rejections, $count) {
-            if (\count($results) !== $count) {
-                throw new AggregateException('Not enough promises to fulfill count', $rejections);
-            }
-            \ksort($results);
-            return \array_values($results);
-        });
-    }
-    /**
-     * Like some(), with 1 as count. However, if the promise fulfills, the
-     * fulfillment value is not an array of 1 but the value directly.
-     *
-     * @param mixed $promises Promises or values.
-     */
-    public static function any($promises) : PromiseInterface
-    {
-        return self::some(1, $promises)->then(function ($values) {
-            return $values[0];
-        });
-    }
-    /**
-     * Returns a promise that is fulfilled when all of the provided promises have
-     * been fulfilled or rejected.
-     *
-     * The returned promise is fulfilled with an array of inspection state arrays.
-     *
-     * @see inspect for the inspection state array format.
-     *
-     * @param mixed $promises Promises or values.
-     */
-    public static function settle($promises) : PromiseInterface
-    {
-        $results = [];
-        return Each::of($promises, function ($value, $idx) use(&$results) : void {
-            $results[$idx] = ['state' => PromiseInterface::FULFILLED, 'value' => $value];
-        }, function ($reason, $idx) use(&$results) : void {
-            $results[$idx] = ['state' => PromiseInterface::REJECTED, 'reason' => $reason];
-        })->then(function () use(&$results) {
-            \ksort($results);
-            return $results;
-        });
-    }
+	/**
+	 * Get the global task queue used for promise resolution.
+	 *
+	 * This task queue MUST be run in an event loop in order for promises to be
+	 * settled asynchronously. It will be automatically run when synchronously
+	 * waiting on a promise.
+	 *
+	 * <code>
+	 * while ($eventLoop->isRunning()) {
+	 *     GuzzleHttp\Promise\Utils::queue()->run();
+	 * }
+	 * </code>
+	 *
+	 * @param TaskQueueInterface|null $assign Optionally specify a new queue instance.
+	 */
+	public static function queue(?TaskQueueInterface $assign = null) : TaskQueueInterface
+	{
+		static $queue;
+		if ($assign) {
+			$queue = $assign;
+		} elseif (!$queue) {
+			$queue = new TaskQueue();
+		}
+		return $queue;
+	}
+	/**
+	 * Adds a function to run in the task queue when it is next `run()` and
+	 * returns a promise that is fulfilled or rejected with the result.
+	 *
+	 * @param callable $task Task function to run.
+	 */
+	public static function task(callable $task) : PromiseInterface
+	{
+		$queue = self::queue();
+		$promise = new Promise([$queue, 'run']);
+		$queue->add(function () use($task, $promise) : void {
+			try {
+				if (Is::pending($promise)) {
+					$promise->resolve($task());
+				}
+			} catch (\Throwable $e) {
+				$promise->reject($e);
+			}
+		});
+		return $promise;
+	}
+	/**
+	 * Synchronously waits on a promise to resolve and returns an inspection
+	 * state array.
+	 *
+	 * Returns a state associative array containing a "state" key mapping to a
+	 * valid promise state. If the state of the promise is "fulfilled", the
+	 * array will contain a "value" key mapping to the fulfilled value of the
+	 * promise. If the promise is rejected, the array will contain a "reason"
+	 * key mapping to the rejection reason of the promise.
+	 *
+	 * @param PromiseInterface $promise Promise or value.
+	 */
+	public static function inspect(PromiseInterface $promise) : array
+	{
+		try {
+			return ['state' => PromiseInterface::FULFILLED, 'value' => $promise->wait()];
+		} catch (RejectionException $e) {
+			return ['state' => PromiseInterface::REJECTED, 'reason' => $e->getReason()];
+		} catch (\Throwable $e) {
+			return ['state' => PromiseInterface::REJECTED, 'reason' => $e];
+		}
+	}
+	/**
+	 * Waits on all of the provided promises, but does not unwrap rejected
+	 * promises as thrown exception.
+	 *
+	 * Returns an array of inspection state arrays.
+	 *
+	 * @see inspect for the inspection state array format.
+	 *
+	 * @param PromiseInterface[] $promises Traversable of promises to wait upon.
+	 */
+	public static function inspectAll($promises) : array
+	{
+		$results = [];
+		foreach ($promises as $key => $promise) {
+			$results[$key] = self::inspect($promise);
+		}
+		return $results;
+	}
+	/**
+	 * Waits on all of the provided promises and returns the fulfilled values.
+	 *
+	 * Returns an array that contains the value of each promise (in the same
+	 * order the promises were provided). An exception is thrown if any of the
+	 * promises are rejected.
+	 *
+	 * @param iterable<PromiseInterface> $promises Iterable of PromiseInterface objects to wait on.
+	 *
+	 * @throws \Throwable on error
+	 */
+	public static function unwrap($promises) : array
+	{
+		$results = [];
+		foreach ($promises as $key => $promise) {
+			$results[$key] = $promise->wait();
+		}
+		return $results;
+	}
+	/**
+	 * Given an array of promises, return a promise that is fulfilled when all
+	 * the items in the array are fulfilled.
+	 *
+	 * The promise's fulfillment value is an array with fulfillment values at
+	 * respective positions to the original array. If any promise in the array
+	 * rejects, the returned promise is rejected with the rejection reason.
+	 *
+	 * @param mixed $promises  Promises or values.
+	 * @param bool  $recursive If true, resolves new promises that might have been added to the stack during its own resolution.
+	 */
+	public static function all($promises, bool $recursive = \false) : PromiseInterface
+	{
+		$results = [];
+		$promise = Each::of($promises, function ($value, $idx) use(&$results) : void {
+			$results[$idx] = $value;
+		}, function ($reason, $idx, Promise $aggregate) : void {
+			if (Is::pending($aggregate)) {
+				$aggregate->reject($reason);
+			}
+		})->then(function () use(&$results) {
+			\ksort($results);
+			return $results;
+		});
+		if (\true === $recursive) {
+			$promise = $promise->then(function ($results) use($recursive, &$promises) {
+				foreach ($promises as $promise) {
+					if (Is::pending($promise)) {
+						return self::all($promises, $recursive);
+					}
+				}
+				return $results;
+			});
+		}
+		return $promise;
+	}
+	/**
+	 * Initiate a competitive race between multiple promises or values (values
+	 * will become immediately fulfilled promises).
+	 *
+	 * When count amount of promises have been fulfilled, the returned promise
+	 * is fulfilled with an array that contains the fulfillment values of the
+	 * winners in order of resolution.
+	 *
+	 * This promise is rejected with a {@see AggregateException} if the number
+	 * of fulfilled promises is less than the desired $count.
+	 *
+	 * @param int   $count    Total number of promises.
+	 * @param mixed $promises Promises or values.
+	 */
+	public static function some(int $count, $promises) : PromiseInterface
+	{
+		$results = [];
+		$rejections = [];
+		return Each::of($promises, function ($value, $idx, PromiseInterface $p) use(&$results, $count) : void {
+			if (Is::settled($p)) {
+				return;
+			}
+			$results[$idx] = $value;
+			if (\count($results) >= $count) {
+				$p->resolve(null);
+			}
+		}, function ($reason) use(&$rejections) : void {
+			$rejections[] = $reason;
+		})->then(function () use(&$results, &$rejections, $count) {
+			if (\count($results) !== $count) {
+				throw new AggregateException('Not enough promises to fulfill count', $rejections);
+			}
+			\ksort($results);
+			return \array_values($results);
+		});
+	}
+	/**
+	 * Like some(), with 1 as count. However, if the promise fulfills, the
+	 * fulfillment value is not an array of 1 but the value directly.
+	 *
+	 * @param mixed $promises Promises or values.
+	 */
+	public static function any($promises) : PromiseInterface
+	{
+		return self::some(1, $promises)->then(function ($values) {
+			return $values[0];
+		});
+	}
+	/**
+	 * Returns a promise that is fulfilled when all of the provided promises have
+	 * been fulfilled or rejected.
+	 *
+	 * The returned promise is fulfilled with an array of inspection state arrays.
+	 *
+	 * @see inspect for the inspection state array format.
+	 *
+	 * @param mixed $promises Promises or values.
+	 */
+	public static function settle($promises) : PromiseInterface
+	{
+		$results = [];
+		return Each::of($promises, function ($value, $idx) use(&$results) : void {
+			$results[$idx] = ['state' => PromiseInterface::FULFILLED, 'value' => $value];
+		}, function ($reason, $idx) use(&$results) : void {
+			$results[$idx] = ['state' => PromiseInterface::REJECTED, 'reason' => $reason];
+		})->then(function () use(&$results) {
+			\ksort($results);
+			return $results;
+		});
+	}
 }

Spacing +13 added lines, -13 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare (strict_types=1);
+declare(strict_types=1);
 namespace OCA\FullTextSearch_Elasticsearch\Vendor\GuzzleHttp\Promise;
 
 final class Utils
@@ -40,7 +40,7 @@ 
     {
         $queue = self::queue();
         $promise = new Promise([$queue, 'run']);
-        $queue->add(function () use($task, $promise) : void {
+        $queue->add(function() use($task, $promise) : void {
             try {
                 if (Is::pending($promise)) {
                     $promise->resolve($task());
@@ -124,18 +124,18 @@ 
     public static function all($promises, bool $recursive = \false) : PromiseInterface
     {
         $results = [];
-        $promise = Each::of($promises, function ($value, $idx) use(&$results) : void {
+        $promise = Each::of($promises, function($value, $idx) use(&$results) : void {
             $results[$idx] = $value;
-        }, function ($reason, $idx, Promise $aggregate) : void {
+        }, function($reason, $idx, Promise $aggregate) : void {
             if (Is::pending($aggregate)) {
                 $aggregate->reject($reason);
             }
-        })->then(function () use(&$results) {
+        })->then(function() use(&$results) {
             \ksort($results);
             return $results;
         });
         if (\true === $recursive) {
-            $promise = $promise->then(function ($results) use($recursive, &$promises) {
+            $promise = $promise->then(function($results) use($recursive, &$promises) {
                 foreach ($promises as $promise) {
                     if (Is::pending($promise)) {
                         return self::all($promises, $recursive);
@@ -164,7 +164,7 @@ 
     {
         $results = [];
         $rejections = [];
-        return Each::of($promises, function ($value, $idx, PromiseInterface $p) use(&$results, $count) : void {
+        return Each::of($promises, function($value, $idx, PromiseInterface $p) use(&$results, $count) : void {
             if (Is::settled($p)) {
                 return;
             }
@@ -172,9 +172,9 @@ 
             if (\count($results) >= $count) {
                 $p->resolve(null);
             }
-        }, function ($reason) use(&$rejections) : void {
+        }, function($reason) use(&$rejections) : void {
             $rejections[] = $reason;
-        })->then(function () use(&$results, &$rejections, $count) {
+        })->then(function() use(&$results, &$rejections, $count) {
             if (\count($results) !== $count) {
                 throw new AggregateException('Not enough promises to fulfill count', $rejections);
             }
@@ -190,7 +190,7 @@ 
      */
     public static function any($promises) : PromiseInterface
     {
-        return self::some(1, $promises)->then(function ($values) {
+        return self::some(1, $promises)->then(function($values) {
             return $values[0];
         });
     }
@@ -207,11 +207,11 @@ 
     public static function settle($promises) : PromiseInterface
     {
         $results = [];
-        return Each::of($promises, function ($value, $idx) use(&$results) : void {
+        return Each::of($promises, function($value, $idx) use(&$results) : void {
             $results[$idx] = ['state' => PromiseInterface::FULFILLED, 'value' => $value];
-        }, function ($reason, $idx) use(&$results) : void {
+        }, function($reason, $idx) use(&$results) : void {
             $results[$idx] = ['state' => PromiseInterface::REJECTED, 'reason' => $reason];
-        })->then(function () use(&$results) {
+        })->then(function() use(&$results) {
             \ksort($results);
             return $results;
         });

lib/Vendor/GuzzleHttp/Promise/Promise.php

Indentation +216 added lines, -216 removed lines

@@ -12,225 +12,225 @@
  */
 class Promise implements PromiseInterface
 {
-    private $state = self::PENDING;
-    private $result;
-    private $cancelFn;
-    private $waitFn;
-    private $waitList;
-    private $handlers = [];
-    /**
-     * @param callable $waitFn   Fn that when invoked resolves the promise.
-     * @param callable $cancelFn Fn that when invoked cancels the promise.
-     */
-    public function __construct(?callable $waitFn = null, ?callable $cancelFn = null)
-    {
-        $this->waitFn = $waitFn;
-        $this->cancelFn = $cancelFn;
-    }
-    public function then(?callable $onFulfilled = null, ?callable $onRejected = null) : PromiseInterface
-    {
-        if ($this->state === self::PENDING) {
-            $p = new Promise(null, [$this, 'cancel']);
-            $this->handlers[] = [$p, $onFulfilled, $onRejected];
-            $p->waitList = $this->waitList;
-            $p->waitList[] = $this;
-            return $p;
-        }
-        // Return a fulfilled promise and immediately invoke any callbacks.
-        if ($this->state === self::FULFILLED) {
-            $promise = Create::promiseFor($this->result);
-            return $onFulfilled ? $promise->then($onFulfilled) : $promise;
-        }
-        // It's either cancelled or rejected, so return a rejected promise
-        // and immediately invoke any callbacks.
-        $rejection = Create::rejectionFor($this->result);
-        return $onRejected ? $rejection->then(null, $onRejected) : $rejection;
-    }
-    public function otherwise(callable $onRejected) : PromiseInterface
-    {
-        return $this->then(null, $onRejected);
-    }
-    public function wait(bool $unwrap = \true)
-    {
-        $this->waitIfPending();
-        if ($this->result instanceof PromiseInterface) {
-            return $this->result->wait($unwrap);
-        }
-        if ($unwrap) {
-            if ($this->state === self::FULFILLED) {
-                return $this->result;
-            }
-            // It's rejected so "unwrap" and throw an exception.
-            throw Create::exceptionFor($this->result);
-        }
-    }
-    public function getState() : string
-    {
-        return $this->state;
-    }
-    public function cancel() : void
-    {
-        if ($this->state !== self::PENDING) {
-            return;
-        }
-        $this->waitFn = $this->waitList = null;
-        if ($this->cancelFn) {
-            $fn = $this->cancelFn;
-            $this->cancelFn = null;
-            try {
-                $fn();
-            } catch (\Throwable $e) {
-                $this->reject($e);
-            }
-        }
-        // Reject the promise only if it wasn't rejected in a then callback.
-        /** @psalm-suppress RedundantCondition */
-        if ($this->state === self::PENDING) {
-            $this->reject(new CancellationException('Promise has been cancelled'));
-        }
-    }
-    public function resolve($value) : void
-    {
-        $this->settle(self::FULFILLED, $value);
-    }
-    public function reject($reason) : void
-    {
-        $this->settle(self::REJECTED, $reason);
-    }
-    private function settle(string $state, $value) : void
-    {
-        if ($this->state !== self::PENDING) {
-            // Ignore calls with the same resolution.
-            if ($state === $this->state && $value === $this->result) {
-                return;
-            }
-            throw $this->state === $state ? new \LogicException("The promise is already {$state}.") : new \LogicException("Cannot change a {$this->state} promise to {$state}");
-        }
-        if ($value === $this) {
-            throw new \LogicException('Cannot fulfill or reject a promise with itself');
-        }
-        // Clear out the state of the promise but stash the handlers.
-        $this->state = $state;
-        $this->result = $value;
-        $handlers = $this->handlers;
-        $this->handlers = null;
-        $this->waitList = $this->waitFn = null;
-        $this->cancelFn = null;
-        if (!$handlers) {
-            return;
-        }
-        // If the value was not a settled promise or a thenable, then resolve
-        // it in the task queue using the correct ID.
-        if (!\is_object($value) || !\method_exists($value, 'then')) {
-            $id = $state === self::FULFILLED ? 1 : 2;
-            // It's a success, so resolve the handlers in the queue.
-            Utils::queue()->add(static function () use($id, $value, $handlers) : void {
-                foreach ($handlers as $handler) {
-                    self::callHandler($id, $value, $handler);
-                }
-            });
-        } elseif ($value instanceof Promise && Is::pending($value)) {
-            // We can just merge our handlers onto the next promise.
-            $value->handlers = \array_merge($value->handlers, $handlers);
-        } else {
-            // Resolve the handlers when the forwarded promise is resolved.
-            $value->then(static function ($value) use($handlers) : void {
-                foreach ($handlers as $handler) {
-                    self::callHandler(1, $value, $handler);
-                }
-            }, static function ($reason) use($handlers) : void {
-                foreach ($handlers as $handler) {
-                    self::callHandler(2, $reason, $handler);
-                }
-            });
-        }
-    }
-    /**
-     * Call a stack of handlers using a specific callback index and value.
-     *
-     * @param int   $index   1 (resolve) or 2 (reject).
-     * @param mixed $value   Value to pass to the callback.
-     * @param array $handler Array of handler data (promise and callbacks).
-     */
-    private static function callHandler(int $index, $value, array $handler) : void
-    {
-        /** @var PromiseInterface $promise */
-        $promise = $handler[0];
-        // The promise may have been cancelled or resolved before placing
-        // this thunk in the queue.
-        if (Is::settled($promise)) {
-            return;
-        }
-        try {
-            if (isset($handler[$index])) {
-                /*
+	private $state = self::PENDING;
+	private $result;
+	private $cancelFn;
+	private $waitFn;
+	private $waitList;
+	private $handlers = [];
+	/**
+	 * @param callable $waitFn   Fn that when invoked resolves the promise.
+	 * @param callable $cancelFn Fn that when invoked cancels the promise.
+	 */
+	public function __construct(?callable $waitFn = null, ?callable $cancelFn = null)
+	{
+		$this->waitFn = $waitFn;
+		$this->cancelFn = $cancelFn;
+	}
+	public function then(?callable $onFulfilled = null, ?callable $onRejected = null) : PromiseInterface
+	{
+		if ($this->state === self::PENDING) {
+			$p = new Promise(null, [$this, 'cancel']);
+			$this->handlers[] = [$p, $onFulfilled, $onRejected];
+			$p->waitList = $this->waitList;
+			$p->waitList[] = $this;
+			return $p;
+		}
+		// Return a fulfilled promise and immediately invoke any callbacks.
+		if ($this->state === self::FULFILLED) {
+			$promise = Create::promiseFor($this->result);
+			return $onFulfilled ? $promise->then($onFulfilled) : $promise;
+		}
+		// It's either cancelled or rejected, so return a rejected promise
+		// and immediately invoke any callbacks.
+		$rejection = Create::rejectionFor($this->result);
+		return $onRejected ? $rejection->then(null, $onRejected) : $rejection;
+	}
+	public function otherwise(callable $onRejected) : PromiseInterface
+	{
+		return $this->then(null, $onRejected);
+	}
+	public function wait(bool $unwrap = \true)
+	{
+		$this->waitIfPending();
+		if ($this->result instanceof PromiseInterface) {
+			return $this->result->wait($unwrap);
+		}
+		if ($unwrap) {
+			if ($this->state === self::FULFILLED) {
+				return $this->result;
+			}
+			// It's rejected so "unwrap" and throw an exception.
+			throw Create::exceptionFor($this->result);
+		}
+	}
+	public function getState() : string
+	{
+		return $this->state;
+	}
+	public function cancel() : void
+	{
+		if ($this->state !== self::PENDING) {
+			return;
+		}
+		$this->waitFn = $this->waitList = null;
+		if ($this->cancelFn) {
+			$fn = $this->cancelFn;
+			$this->cancelFn = null;
+			try {
+				$fn();
+			} catch (\Throwable $e) {
+				$this->reject($e);
+			}
+		}
+		// Reject the promise only if it wasn't rejected in a then callback.
+		/** @psalm-suppress RedundantCondition */
+		if ($this->state === self::PENDING) {
+			$this->reject(new CancellationException('Promise has been cancelled'));
+		}
+	}
+	public function resolve($value) : void
+	{
+		$this->settle(self::FULFILLED, $value);
+	}
+	public function reject($reason) : void
+	{
+		$this->settle(self::REJECTED, $reason);
+	}
+	private function settle(string $state, $value) : void
+	{
+		if ($this->state !== self::PENDING) {
+			// Ignore calls with the same resolution.
+			if ($state === $this->state && $value === $this->result) {
+				return;
+			}
+			throw $this->state === $state ? new \LogicException("The promise is already {$state}.") : new \LogicException("Cannot change a {$this->state} promise to {$state}");
+		}
+		if ($value === $this) {
+			throw new \LogicException('Cannot fulfill or reject a promise with itself');
+		}
+		// Clear out the state of the promise but stash the handlers.
+		$this->state = $state;
+		$this->result = $value;
+		$handlers = $this->handlers;
+		$this->handlers = null;
+		$this->waitList = $this->waitFn = null;
+		$this->cancelFn = null;
+		if (!$handlers) {
+			return;
+		}
+		// If the value was not a settled promise or a thenable, then resolve
+		// it in the task queue using the correct ID.
+		if (!\is_object($value) || !\method_exists($value, 'then')) {
+			$id = $state === self::FULFILLED ? 1 : 2;
+			// It's a success, so resolve the handlers in the queue.
+			Utils::queue()->add(static function () use($id, $value, $handlers) : void {
+				foreach ($handlers as $handler) {
+					self::callHandler($id, $value, $handler);
+				}
+			});
+		} elseif ($value instanceof Promise && Is::pending($value)) {
+			// We can just merge our handlers onto the next promise.
+			$value->handlers = \array_merge($value->handlers, $handlers);
+		} else {
+			// Resolve the handlers when the forwarded promise is resolved.
+			$value->then(static function ($value) use($handlers) : void {
+				foreach ($handlers as $handler) {
+					self::callHandler(1, $value, $handler);
+				}
+			}, static function ($reason) use($handlers) : void {
+				foreach ($handlers as $handler) {
+					self::callHandler(2, $reason, $handler);
+				}
+			});
+		}
+	}
+	/**
+	 * Call a stack of handlers using a specific callback index and value.
+	 *
+	 * @param int   $index   1 (resolve) or 2 (reject).
+	 * @param mixed $value   Value to pass to the callback.
+	 * @param array $handler Array of handler data (promise and callbacks).
+	 */
+	private static function callHandler(int $index, $value, array $handler) : void
+	{
+		/** @var PromiseInterface $promise */
+		$promise = $handler[0];
+		// The promise may have been cancelled or resolved before placing
+		// this thunk in the queue.
+		if (Is::settled($promise)) {
+			return;
+		}
+		try {
+			if (isset($handler[$index])) {
+				/*
                  * If $f throws an exception, then $handler will be in the exception
                  * stack trace. Since $handler contains a reference to the callable
                  * itself we get a circular reference. We clear the $handler
                  * here to avoid that memory leak.
                  */
-                $f = $handler[$index];
-                unset($handler);
-                $promise->resolve($f($value));
-            } elseif ($index === 1) {
-                // Forward resolution values as-is.
-                $promise->resolve($value);
-            } else {
-                // Forward rejections down the chain.
-                $promise->reject($value);
-            }
-        } catch (\Throwable $reason) {
-            $promise->reject($reason);
-        }
-    }
-    private function waitIfPending() : void
-    {
-        if ($this->state !== self::PENDING) {
-            return;
-        } elseif ($this->waitFn) {
-            $this->invokeWaitFn();
-        } elseif ($this->waitList) {
-            $this->invokeWaitList();
-        } else {
-            // If there's no wait function, then reject the promise.
-            $this->reject('Cannot wait on a promise that has ' . 'no internal wait function. You must provide a wait ' . 'function when constructing the promise to be able to ' . 'wait on a promise.');
-        }
-        Utils::queue()->run();
-        /** @psalm-suppress RedundantCondition */
-        if ($this->state === self::PENDING) {
-            $this->reject('Invoking the wait callback did not resolve the promise');
-        }
-    }
-    private function invokeWaitFn() : void
-    {
-        try {
-            $wfn = $this->waitFn;
-            $this->waitFn = null;
-            $wfn(\true);
-        } catch (\Throwable $reason) {
-            if ($this->state === self::PENDING) {
-                // The promise has not been resolved yet, so reject the promise
-                // with the exception.
-                $this->reject($reason);
-            } else {
-                // The promise was already resolved, so there's a problem in
-                // the application.
-                throw $reason;
-            }
-        }
-    }
-    private function invokeWaitList() : void
-    {
-        $waitList = $this->waitList;
-        $this->waitList = null;
-        foreach ($waitList as $result) {
-            do {
-                $result->waitIfPending();
-                $result = $result->result;
-            } while ($result instanceof Promise);
-            if ($result instanceof PromiseInterface) {
-                $result->wait(\false);
-            }
-        }
-    }
+				$f = $handler[$index];
+				unset($handler);
+				$promise->resolve($f($value));
+			} elseif ($index === 1) {
+				// Forward resolution values as-is.
+				$promise->resolve($value);
+			} else {
+				// Forward rejections down the chain.
+				$promise->reject($value);
+			}
+		} catch (\Throwable $reason) {
+			$promise->reject($reason);
+		}
+	}
+	private function waitIfPending() : void
+	{
+		if ($this->state !== self::PENDING) {
+			return;
+		} elseif ($this->waitFn) {
+			$this->invokeWaitFn();
+		} elseif ($this->waitList) {
+			$this->invokeWaitList();
+		} else {
+			// If there's no wait function, then reject the promise.
+			$this->reject('Cannot wait on a promise that has ' . 'no internal wait function. You must provide a wait ' . 'function when constructing the promise to be able to ' . 'wait on a promise.');
+		}
+		Utils::queue()->run();
+		/** @psalm-suppress RedundantCondition */
+		if ($this->state === self::PENDING) {
+			$this->reject('Invoking the wait callback did not resolve the promise');
+		}
+	}
+	private function invokeWaitFn() : void
+	{
+		try {
+			$wfn = $this->waitFn;
+			$this->waitFn = null;
+			$wfn(\true);
+		} catch (\Throwable $reason) {
+			if ($this->state === self::PENDING) {
+				// The promise has not been resolved yet, so reject the promise
+				// with the exception.
+				$this->reject($reason);
+			} else {
+				// The promise was already resolved, so there's a problem in
+				// the application.
+				throw $reason;
+			}
+		}
+	}
+	private function invokeWaitList() : void
+	{
+		$waitList = $this->waitList;
+		$this->waitList = null;
+		foreach ($waitList as $result) {
+			do {
+				$result->waitIfPending();
+				$result = $result->result;
+			} while ($result instanceof Promise);
+			if ($result instanceof PromiseInterface) {
+				$result->wait(\false);
+			}
+		}
+	}
 }