vendor/symfony/http-client/Response/ResponseTrait.php line 95

Open in your IDE?
  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\Response;
  14. use Symfony\Component\HttpClient\Chunk\DataChunk;
  15. use Symfony\Component\HttpClient\Chunk\ErrorChunk;
  16. use Symfony\Component\HttpClient\Chunk\FirstChunk;
  17. use Symfony\Component\HttpClient\Chunk\LastChunk;
  18. use Symfony\Component\HttpClient\Exception\ClientException;
  19. use Symfony\Component\HttpClient\Exception\JsonException;
  20. use Symfony\Component\HttpClient\Exception\RedirectionException;
  21. use Symfony\Component\HttpClient\Exception\ServerException;
  22. use Symfony\Component\HttpClient\Exception\TransportException;
  23. use Symfony\Component\HttpClient\Internal\ClientState;
  24. use Symfony\Contracts\HttpClient\Exception\ClientExceptionInterface;
  25. use Symfony\Contracts\HttpClient\Exception\RedirectionExceptionInterface;
  26. use Symfony\Contracts\HttpClient\Exception\ServerExceptionInterface;
  27. use Symfony\Contracts\HttpClient\Exception\TransportExceptionInterface;
  29. /**
  30.  * Implements the common logic for response classes.
  31.  *
  32.  * @author Nicolas Grekas <p@tchwork.com>
  33.  *
  34.  * @internal
  35.  */
  36. trait ResponseTrait
  37. {
  38.     private $logger;
  39.     private $headers = [];
  41.     /**
  42.      * @var callable|null A callback that initializes the two previous properties
  43.      */
  44.     private $initializer;
  46.     private $info = [
  47.         'response_headers' => [],
  48.         'http_code' => 0,
  49.         'error' => null,
  50.         'canceled' => false,
  51.     ];
  53.     /** @var object|resource */
  54.     private $handle;
  55.     private $id;
  56.     private $timeout = 0;
  57.     private $inflate;
  58.     private $shouldBuffer;
  59.     private $content;
  60.     private $finalInfo;
  61.     private $offset = 0;
  62.     private $jsonData;
  64.     /**
  65.      * {@inheritdoc}
  66.      */
  67.     public function getStatusCode(): int
  68.     {
  69.         if ($this->initializer) {
  70.             self::initialize($this);
  71.         }
  73.         return $this->info['http_code'];
  74.     }
  76.     /**
  77.      * {@inheritdoc}
  78.      */
  79.     public function getHeaders(bool $throw = true): array
  80.     {
  81.         if ($this->initializer) {
  82.             self::initialize($this);
  83.         }
  85.         if ($throw) {
  86.             $this->checkStatusCode();
  87.         }
  89.         return $this->headers;
  90.     }
  92.     /**
  93.      * {@inheritdoc}
  94.      */
  95.     public function getContent(bool $throw = true): string
  96.     {
  97.         if ($this->initializer) {
  98.             self::initialize($this);
  99.         }
  101.         if ($throw) {
  102.             $this->checkStatusCode();
  103.         }
  105.         if (null === $this->content) {
  106.             $content = null;
  108.             foreach (self::stream([$this]) as $chunk) {
  109.                 if (!$chunk->isLast()) {
  110.                     $content .= $chunk->getContent();
  111.                 }
  112.             }
  114.             if (null !== $content) {
  115.                 return $content;
  116.             }
  118.             if ('HEAD' === $this->info['http_method'] || \in_array($this->info['http_code'], [204, 304], true)) {
  119.                 return '';
  120.             }
  122.             throw new TransportException('Cannot get the content of the response twice: buffering is disabled.');
  123.         }
  125.         foreach (self::stream([$this]) as $chunk) {
  126.             // Chunks are buffered in $this->content already
  127.         }
  129.         rewind($this->content);
  131.         return stream_get_contents($this->content);
  132.     }
  134.     /**
  135.      * {@inheritdoc}
  136.      */
  137.     public function toArray(bool $throw = true): array
  138.     {
  139.         if ('' === $content = $this->getContent($throw)) {
  140.             throw new JsonException('Response body is empty.');
  141.         }
  143.         if (null !== $this->jsonData) {
  144.             return $this->jsonData;
  145.         }
  147.         $contentType = $this->headers['content-type'][0] ?? 'application/json';
  149.         if (!preg_match('/\bjson\b/i', $contentType)) {
  150.             throw new JsonException(sprintf('Response content-type is "%s" while a JSON-compatible one was expected for "%s".', $contentType, $this->getInfo('url')));
  151.         }
  153.         try {
  154.             $content = json_decode($content, true, 512, JSON_BIGINT_AS_STRING | (\PHP_VERSION_ID >= 70300 ? JSON_THROW_ON_ERROR : 0));
  155.         } catch (\JsonException $e) {
  156.             throw new JsonException($e->getMessage().sprintf(' for "%s".', $this->getInfo('url')), $e->getCode());
  157.         }
  159.         if (\PHP_VERSION_ID < 70300 && JSON_ERROR_NONE !== json_last_error()) {
  160.             throw new JsonException(json_last_error_msg().sprintf(' for "%s".', $this->getInfo('url')), json_last_error());
  161.         }
  163.         if (!\is_array($content)) {
  164.             throw new JsonException(sprintf('JSON content was expected to decode to an array, "%s" returned for "%s".', \gettype($content), $this->getInfo('url')));
  165.         }
  167.         if (null !== $this->content) {
  168.             // Option "buffer" is true
  169.             return $this->jsonData = $content;
  170.         }
  172.         return $content;
  173.     }
  175.     /**
  176.      * {@inheritdoc}
  177.      */
  178.     public function cancel(): void
  179.     {
  180.         $this->info['canceled'] = true;
  181.         $this->info['error'] = 'Response has been canceled.';
  182.         $this->close();
  183.     }
  185.     /**
  186.      * Casts the response to a PHP stream resource.
  187.      *
  188.      * @return resource
  189.      *
  190.      * @throws TransportExceptionInterface   When a network error occurs
  191.      * @throws RedirectionExceptionInterface On a 3xx when $throw is true and the "max_redirects" option has been reached
  192.      * @throws ClientExceptionInterface      On a 4xx when $throw is true
  193.      * @throws ServerExceptionInterface      On a 5xx when $throw is true
  194.      */
  195.     public function toStream(bool $throw = true)
  196.     {
  197.         if ($throw) {
  198.             // Ensure headers arrived
  199.             $this->getHeaders($throw);
  200.         }
  202.         $stream = StreamWrapper::createResource($this);
  203.         stream_get_meta_data($stream)['wrapper_data']
  204.             ->bindHandles($this->handle, $this->content);
  206.         return $stream;
  207.     }
  209.     /**
  210.      * Closes the response and all its network handles.
  211.      */
  212.     abstract protected function close(): void;
  214.     /**
  215.      * Adds pending responses to the activity list.
  216.      */
  217.     abstract protected static function schedule(self $response, array &$runningResponses): void;
  219.     /**
  220.      * Performs all pending non-blocking operations.
  221.      */
  222.     abstract protected static function perform(ClientState $multi, array &$responses): void;
  224.     /**
  225.      * Waits for network activity.
  226.      */
  227.     abstract protected static function select(ClientState $multi, float $timeout): int;
  229.     private static function initialize(self $response): void
  230.     {
  231.         if (null !== $response->info['error']) {
  232.             throw new TransportException($response->info['error']);
  233.         }
  235.         try {
  236.             if (($response->initializer)($response)) {
  237.                 foreach (self::stream([$response]) as $chunk) {
  238.                     if ($chunk->isFirst()) {
  239.                         break;
  240.                     }
  241.                 }
  242.             }
  243.         } catch (\Throwable $e) {
  244.             // Persist timeouts thrown during initialization
  245.             $response->info['error'] = $e->getMessage();
  246.             $response->close();
  247.             throw $e;
  248.         }
  250.         $response->initializer = null;
  251.     }
  253.     private static function addResponseHeaders(array $responseHeaders, array &$info, array &$headers, string &$debug = ''): void
  254.     {
  255.         foreach ($responseHeaders as $h) {
  256.             if (11 <= \strlen($h) && '/' === $h[4] && preg_match('#^HTTP/\d+(?:\.\d+)? ([1-9]\d\d)(?: |$)#', $h, $m)) {
  257.                 if ($headers) {
  258.                     $debug .= "< \r\n";
  259.                     $headers = [];
  260.                 }
  261.                 $info['http_code'] = (int) $m[1];
  262.             } elseif (2 === \count($m = explode(':', $h, 2))) {
  263.                 $headers[strtolower($m[0])][] = ltrim($m[1]);
  264.             }
  266.             $debug .= "< {$h}\r\n";
  267.             $info['response_headers'][] = $h;
  268.         }
  270.         $debug .= "< \r\n";
  272.         if (!$info['http_code']) {
  273.             throw new TransportException('Invalid or missing HTTP status line.');
  274.         }
  275.     }
  277.     private function checkStatusCode()
  278.     {
  279.         if (500 <= $this->info['http_code']) {
  280.             throw new ServerException($this);
  281.         }
  283.         if (400 <= $this->info['http_code']) {
  284.             throw new ClientException($this);
  285.         }
  287.         if (300 <= $this->info['http_code']) {
  288.             throw new RedirectionException($this);
  289.         }
  290.     }
  292.     /**
  293.      * Ensures the request is always sent and that the response code was checked.
  294.      */
  295.     private function doDestruct()
  296.     {
  297.         $this->shouldBuffer = true;
  299.         if ($this->initializer && null === $this->info['error']) {
  300.             self::initialize($this);
  301.             $this->checkStatusCode();
  302.         }
  303.     }
  305.     /**
  306.      * Implements an event loop based on a buffer activity queue.
  307.      *
  308.      * @internal
  309.      */
  310.     public static function stream(iterable $responses, float $timeout = null): \Generator
  311.     {
  312.         $runningResponses = [];
  314.         foreach ($responses as $response) {
  315.             self::schedule($response, $runningResponses);
  316.         }
  318.         $lastActivity = microtime(true);
  319.         $enlapsedTimeout = 0;
  321.         while (true) {
  322.             $hasActivity = false;
  323.             $timeoutMax = 0;
  324.             $timeoutMin = $timeout ?? INF;
  326.             /** @var ClientState $multi */
  327.             foreach ($runningResponses as $i => [$multi]) {
  328.                 $responses = &$runningResponses[$i][1];
  329.                 self::perform($multi, $responses);
  331.                 foreach ($responses as $j => $response) {
  332.                     $timeoutMax = $timeout ?? max($timeoutMax, $response->timeout);
  333.                     $timeoutMin = min($timeoutMin, $response->timeout, 1);
  334.                     $chunk = false;
  336.                     if (isset($multi->handlesActivity[$j])) {
  337.                         // no-op
  338.                     } elseif (!isset($multi->openHandles[$j])) {
  339.                         unset($responses[$j]);
  340.                         continue;
  341.                     } elseif ($enlapsedTimeout >= $timeoutMax) {
  342.                         $multi->handlesActivity[$j] = [new ErrorChunk($response->offset, sprintf('Idle timeout reached for "%s".', $response->getInfo('url')))];
  343.                     } else {
  344.                         continue;
  345.                     }
  347.                     while ($multi->handlesActivity[$j] ?? false) {
  348.                         $hasActivity = true;
  349.                         $enlapsedTimeout = 0;
  351.                         if (\is_string($chunk = array_shift($multi->handlesActivity[$j]))) {
  352.                             if (null !== $response->inflate && false === $chunk = @inflate_add($response->inflate, $chunk)) {
  353.                                 $multi->handlesActivity[$j] = [null, new TransportException('Error while processing content unencoding.')];
  354.                                 continue;
  355.                             }
  357.                             if ('' !== $chunk && null !== $response->content && \strlen($chunk) !== fwrite($response->content, $chunk)) {
  358.                                 $multi->handlesActivity[$j] = [null, new TransportException(sprintf('Failed writing %d bytes to the response buffer.', \strlen($chunk)))];
  359.                                 continue;
  360.                             }
  362.                             $chunkLen = \strlen($chunk);
  363.                             $chunk = new DataChunk($response->offset, $chunk);
  364.                             $response->offset += $chunkLen;
  365.                         } elseif (null === $chunk) {
  366.                             $e = $multi->handlesActivity[$j][0];
  367.                             unset($responses[$j], $multi->handlesActivity[$j]);
  368.                             $response->close();
  370.                             if (null !== $e) {
  371.                                 $response->info['error'] = $e->getMessage();
  373.                                 if ($e instanceof \Error) {
  374.                                     throw $e;
  375.                                 }
  377.                                 $chunk = new ErrorChunk($response->offset, $e);
  378.                             } else {
  379.                                 $chunk = new LastChunk($response->offset);
  380.                             }
  381.                         } elseif ($chunk instanceof ErrorChunk) {
  382.                             unset($responses[$j]);
  383.                             $enlapsedTimeout = $timeoutMax;
  384.                         } elseif ($chunk instanceof FirstChunk) {
  385.                             if ($response->logger) {
  386.                                 $info = $response->getInfo();
  387.                                 $response->logger->info(sprintf('Response: "%s %s"', $info['http_code'], $info['url']));
  388.                             }
  390.                             $response->inflate = \extension_loaded('zlib') && $response->inflate && 'gzip' === ($response->headers['content-encoding'][0] ?? null) ? inflate_init(ZLIB_ENCODING_GZIP) : null;
  392.                             if ($response->shouldBuffer instanceof \Closure) {
  393.                                 try {
  394.                                     $response->shouldBuffer = ($response->shouldBuffer)($response->headers);
  396.                                     if (null !== $response->info['error']) {
  397.                                         throw new TransportException($response->info['error']);
  398.                                     }
  399.                                 } catch (\Throwable $e) {
  400.                                     $response->close();
  401.                                     $multi->handlesActivity[$j] = [null, $e];
  402.                                 }
  403.                             }
  405.                             if (true === $response->shouldBuffer) {
  406.                                 $response->content = fopen('php://temp', 'w+');
  407.                             } elseif (\is_resource($response->shouldBuffer)) {
  408.                                 $response->content = $response->shouldBuffer;
  409.                             }
  410.                             $response->shouldBuffer = null;
  412.                             yield $response => $chunk;
  414.                             if ($response->initializer && null === $response->info['error']) {
  415.                                 // Ensure the HTTP status code is always checked
  416.                                 $response->getHeaders(true);
  417.                             }
  419.                             continue;
  420.                         }
  422.                         yield $response => $chunk;
  423.                     }
  425.                     unset($multi->handlesActivity[$j]);
  427.                     if ($chunk instanceof ErrorChunk && !$chunk->didThrow()) {
  428.                         // Ensure transport exceptions are always thrown
  429.                         $chunk->getContent();
  430.                     }
  431.                 }
  433.                 if (!$responses) {
  434.                     unset($runningResponses[$i]);
  435.                 }
  437.                 // Prevent memory leaks
  438.                 $multi->handlesActivity = $multi->handlesActivity ?: [];
  439.                 $multi->openHandles = $multi->openHandles ?: [];
  440.             }
  442.             if (!$runningResponses) {
  443.                 break;
  444.             }
  446.             if ($hasActivity) {
  447.                 $lastActivity = microtime(true);
  448.                 continue;
  449.             }
  451.             if (-1 === self::select($multi, min($timeoutMin, $timeoutMax - $enlapsedTimeout))) {
  452.                 usleep(min(500, 1E6 * $timeoutMin));
  453.             }
  455.             $enlapsedTimeout = microtime(true) - $lastActivity;
  456.         }
  457.     }
  458. }