vendor/symfony/http-client/HttplugClient.php line 134

  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\HttpClient;
  14. use GuzzleHttp\Promise\Promise as GuzzlePromise;
  15. use GuzzleHttp\Promise\RejectedPromise;
  16. use GuzzleHttp\Promise\Utils;
  17. use Http\Client\Exception\NetworkException;
  18. use Http\Client\Exception\RequestException;
  19. use Http\Client\HttpAsyncClient;
  20. use Http\Client\HttpClient as HttplugInterface;
  21. use Http\Discovery\Exception\NotFoundException;
  22. use Http\Discovery\Psr17FactoryDiscovery;
  23. use Http\Message\RequestFactory;
  24. use Http\Message\StreamFactory;
  25. use Http\Message\UriFactory;
  26. use Nyholm\Psr7\Factory\Psr17Factory;
  27. use Nyholm\Psr7\Request;
  28. use Nyholm\Psr7\Uri;
  29. use Psr\Http\Message\RequestFactoryInterface;
  30. use Psr\Http\Message\RequestInterface;
  31. use Psr\Http\Message\ResponseFactoryInterface;
  32. use Psr\Http\Message\ResponseInterface as Psr7ResponseInterface;
  33. use Psr\Http\Message\StreamFactoryInterface;
  34. use Psr\Http\Message\StreamInterface;
  35. use Psr\Http\Message\UriFactoryInterface;
  36. use Psr\Http\Message\UriInterface;
  37. use Symfony\Component\HttpClient\Internal\HttplugWaitLoop;
  38. use Symfony\Component\HttpClient\Response\HttplugPromise;
  39. use Symfony\Contracts\HttpClient\Exception\TransportExceptionInterface;
  40. use Symfony\Contracts\HttpClient\HttpClientInterface;
  41. use Symfony\Contracts\HttpClient\ResponseInterface;
  42. use Symfony\Contracts\Service\ResetInterface;
  44. if (!interface_exists(HttplugInterface::class)) {
  45.     throw new \LogicException('You cannot use "Symfony\Component\HttpClient\HttplugClient" as the "php-http/httplug" package is not installed. Try running "composer require php-http/httplug".');
  46. }
  48. if (!interface_exists(RequestFactory::class)) {
  49.     throw new \LogicException('You cannot use "Symfony\Component\HttpClient\HttplugClient" as the "php-http/message-factory" package is not installed. Try running "composer require php-http/message-factory".');
  50. }
  52. if (!interface_exists(RequestFactoryInterface::class)) {
  53.     throw new \LogicException('You cannot use the "Symfony\Component\HttpClient\HttplugClient" as the "psr/http-factory" package is not installed. Try running "composer require nyholm/psr7".');
  54. }
  56. /**
  57.  * An adapter to turn a Symfony HttpClientInterface into an Httplug client.
  58.  *
  59.  * Run "composer require nyholm/psr7" to install an efficient implementation of response
  60.  * and stream factories with flex-provided autowiring aliases.
  61.  *
  62.  * @author Nicolas Grekas <p@tchwork.com>
  63.  */
  64. final class HttplugClient implements HttplugInterface, HttpAsyncClient, RequestFactoryInterface, StreamFactoryInterface, UriFactoryInterface, RequestFactory, StreamFactory, UriFactory, ResetInterface
  65. {
  66.     private HttpClientInterface $client;
  67.     private ResponseFactoryInterface $responseFactory;
  68.     private StreamFactoryInterface $streamFactory;
  70.     /**
  71.      * @var \SplObjectStorage<ResponseInterface, array{RequestInterface, Promise}>|null
  72.      */
  73.     private ?\SplObjectStorage $promisePool;
  75.     private HttplugWaitLoop $waitLoop;
  77.     public function __construct(HttpClientInterface $client = null, ResponseFactoryInterface $responseFactory = null, StreamFactoryInterface $streamFactory = null)
  78.     {
  79.         $this->client = $client ?? HttpClient::create();
  80.         $streamFactory ??= $responseFactory instanceof StreamFactoryInterface ? $responseFactory : null;
  81.         $this->promisePool = class_exists(Utils::class) ? new \SplObjectStorage() : null;
  83.         if (null === $responseFactory || null === $streamFactory) {
  84.             if (!class_exists(Psr17Factory::class) && !class_exists(Psr17FactoryDiscovery::class)) {
  85.                 throw new \LogicException('You cannot use the "Symfony\Component\HttpClient\HttplugClient" as no PSR-17 factories have been provided. Try running "composer require nyholm/psr7".');
  86.             }
  88.             try {
  89.                 $psr17Factory = class_exists(Psr17Factory::class, false) ? new Psr17Factory() : null;
  90.                 $responseFactory ??= $psr17Factory ?? Psr17FactoryDiscovery::findResponseFactory();
  91.                 $streamFactory ??= $psr17Factory ?? Psr17FactoryDiscovery::findStreamFactory();
  92.             } catch (NotFoundException $e) {
  93.                 throw new \LogicException('You cannot use the "Symfony\Component\HttpClient\HttplugClient" as no PSR-17 factories have been found. Try running "composer require nyholm/psr7".', 0, $e);
  94.             }
  95.         }
  97.         $this->responseFactory = $responseFactory;
  98.         $this->streamFactory = $streamFactory;
  99.         $this->waitLoop = new HttplugWaitLoop($this->client, $this->promisePool, $this->responseFactory, $this->streamFactory);
  100.     }
  102.     public function withOptions(array $options): static
  103.     {
  104.         $clone = clone $this;
  105.         $clone->client = $clone->client->withOptions($options);
  107.         return $clone;
  108.     }
  110.     public function sendRequest(RequestInterface $request): Psr7ResponseInterface
  111.     {
  112.         try {
  113.             return $this->waitLoop->createPsr7Response($this->sendPsr7Request($request));
  114.         } catch (TransportExceptionInterface $e) {
  115.             throw new NetworkException($e->getMessage(), $request, $e);
  116.         }
  117.     }
  119.     public function sendAsyncRequest(RequestInterface $request): HttplugPromise
  120.     {
  121.         if (!$promisePool = $this->promisePool) {
  122.             throw new \LogicException(sprintf('You cannot use "%s()" as the "guzzlehttp/promises" package is not installed. Try running "composer require guzzlehttp/promises".', __METHOD__));
  123.         }
  125.         try {
  126.             $response = $this->sendPsr7Request($request, true);
  127.         } catch (NetworkException $e) {
  128.             return new HttplugPromise(new RejectedPromise($e));
  129.         }
  131.         $waitLoop = $this->waitLoop;
  133.         $promise = new GuzzlePromise(static function () use ($response, $waitLoop) {
  134.             $waitLoop->wait($response);
  135.         }, static function () use ($response, $promisePool) {
  136.             $response->cancel();
  137.             unset($promisePool[$response]);
  138.         });
  140.         $promisePool[$response] = [$request, $promise];
  142.         return new HttplugPromise($promise);
  143.     }
  145.     /**
  146.      * Resolves pending promises that complete before the timeouts are reached.
  147.      *
  148.      * When $maxDuration is null and $idleTimeout is reached, promises are rejected.
  149.      *
  150.      * @return int The number of remaining pending promises
  151.      */
  152.     public function wait(float $maxDuration = null, float $idleTimeout = null): int
  153.     {
  154.         return $this->waitLoop->wait(null, $maxDuration, $idleTimeout);
  155.     }
  157.     /**
  158.      * @param string              $method
  159.      * @param UriInterface|string $uri
  160.      */
  161.     public function createRequest($method, $uri, array $headers = [], $body = null, $protocolVersion = '1.1'): RequestInterface
  162.     {
  163.         if (2 < \func_num_args()) {
  164.             trigger_deprecation('symfony/http-client', '6.2', 'Passing more than 2 arguments to "%s()" is deprecated.', __METHOD__);
  165.         }
  166.         if ($this->responseFactory instanceof RequestFactoryInterface) {
  167.             $request = $this->responseFactory->createRequest($method, $uri);
  168.         } elseif (class_exists(Request::class)) {
  169.             $request = new Request($method, $uri);
  170.         } elseif (class_exists(Psr17FactoryDiscovery::class)) {
  171.             $request = Psr17FactoryDiscovery::findRequestFactory()->createRequest($method, $uri);
  172.         } else {
  173.             throw new \LogicException(sprintf('You cannot use "%s()" as the "nyholm/psr7" package is not installed. Try running "composer require nyholm/psr7".', __METHOD__));
  174.         }
  176.         $request = $request
  177.             ->withProtocolVersion($protocolVersion)
  178.             ->withBody($this->createStream($body ?? ''))
  179.         ;
  181.         foreach ($headers as $name => $value) {
  182.             $request = $request->withAddedHeader($name, $value);
  183.         }
  185.         return $request;
  186.     }
  188.     /**
  189.      * @param string $content
  190.      */
  191.     public function createStream($content = ''): StreamInterface
  192.     {
  193.         if (!\is_string($content)) {
  194.             trigger_deprecation('symfony/http-client', '6.2', 'Passing a "%s" to "%s()" is deprecated, use "createStreamFrom*()" instead.', get_debug_type($content), __METHOD__);
  195.         }
  197.         if ($content instanceof StreamInterface) {
  198.             return $content;
  199.         }
  201.         if (\is_string($content ?? '')) {
  202.             $stream = $this->streamFactory->createStream($content ?? '');
  203.         } elseif (\is_resource($content)) {
  204.             $stream = $this->streamFactory->createStreamFromResource($content);
  205.         } else {
  206.             throw new \InvalidArgumentException(sprintf('"%s()" expects string, resource or StreamInterface, "%s" given.', __METHOD__, get_debug_type($content)));
  207.         }
  209.         if ($stream->isSeekable()) {
  210.             $stream->seek(0);
  211.         }
  213.         return $stream;
  214.     }
  216.     public function createStreamFromFile(string $filename, string $mode = 'r'): StreamInterface
  217.     {
  218.         return $this->streamFactory->createStreamFromFile($filename, $mode);
  219.     }
  221.     public function createStreamFromResource($resource): StreamInterface
  222.     {
  223.         return $this->streamFactory->createStreamFromResource($resource);
  224.     }
  226.     /**
  227.      * @param string $uri
  228.      */
  229.     public function createUri($uri = ''): UriInterface
  230.     {
  231.         if (!\is_string($uri)) {
  232.             trigger_deprecation('symfony/http-client', '6.2', 'Passing a "%s" to "%s()" is deprecated, pass a string instead.', get_debug_type($uri), __METHOD__);
  233.         }
  235.         if ($uri instanceof UriInterface) {
  236.             return $uri;
  237.         }
  239.         if ($this->responseFactory instanceof UriFactoryInterface) {
  240.             return $this->responseFactory->createUri($uri);
  241.         }
  243.         if (class_exists(Uri::class)) {
  244.             return new Uri($uri);
  245.         }
  247.         if (class_exists(Psr17FactoryDiscovery::class)) {
  248.             return Psr17FactoryDiscovery::findUrlFactory()->createUri($uri);
  249.         }
  251.         throw new \LogicException(sprintf('You cannot use "%s()" as the "nyholm/psr7" package is not installed. Try running "composer require nyholm/psr7".', __METHOD__));
  252.     }
  254.     public function __sleep(): array
  255.     {
  256.         throw new \BadMethodCallException('Cannot serialize '.__CLASS__);
  257.     }
  259.     public function __wakeup()
  260.     {
  261.         throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
  262.     }
  264.     public function __destruct()
  265.     {
  266.         $this->wait();
  267.     }
  269.     public function reset()
  270.     {
  271.         if ($this->client instanceof ResetInterface) {
  272.             $this->client->reset();
  273.         }
  274.     }
  276.     private function sendPsr7Request(RequestInterface $request, bool $buffer = null): ResponseInterface
  277.     {
  278.         try {
  279.             $body = $request->getBody();
  281.             if ($body->isSeekable()) {
  282.                 $body->seek(0);
  283.             }
  285.             $options = [
  286.                 'headers' => $request->getHeaders(),
  287.                 'body' => $body->getContents(),
  288.                 'buffer' => $buffer,
  289.             ];
  291.             if ('1.0' === $request->getProtocolVersion()) {
  292.                 $options['http_version'] = '1.0';
  293.             }
  295.             return $this->client->request($request->getMethod(), (string) $request->getUri(), $options);
  296.         } catch (\InvalidArgumentException $e) {
  297.             throw new RequestException($e->getMessage(), $request, $e);
  298.         } catch (TransportExceptionInterface $e) {
  299.             throw new NetworkException($e->getMessage(), $request, $e);
  300.         }
  301.     }
  302. }