vendor/symfony/http-client/Response/CommonResponseTrait.php line 132

  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\Exception\ClientException;
  15. use Symfony\Component\HttpClient\Exception\JsonException;
  16. use Symfony\Component\HttpClient\Exception\RedirectionException;
  17. use Symfony\Component\HttpClient\Exception\ServerException;
  18. use Symfony\Component\HttpClient\Exception\TransportException;
  20. /**
  21.  * Implements common logic for response classes.
  22.  *
  23.  * @author Nicolas Grekas <p@tchwork.com>
  24.  *
  25.  * @internal
  26.  */
  27. trait CommonResponseTrait
  28. {
  29.     /**
  30.      * @var callable|null A callback that tells whether we're waiting for response headers
  31.      */
  32.     private $initializer;
  33.     private $shouldBuffer;
  34.     private $content;
  35.     private int $offset = 0;
  36.     private ?array $jsonData = null;
  38.     public function getContent(bool $throw = true): string
  39.     {
  40.         if ($this->initializer) {
  41.             self::initialize($this);
  42.         }
  44.         if ($throw) {
  45.             $this->checkStatusCode();
  46.         }
  48.         if (null === $this->content) {
  49.             $content = null;
  51.             foreach (self::stream([$this]) as $chunk) {
  52.                 if (!$chunk->isLast()) {
  53.                     $content .= $chunk->getContent();
  54.                 }
  55.             }
  57.             if (null !== $content) {
  58.                 return $content;
  59.             }
  61.             if (null === $this->content) {
  62.                 throw new TransportException('Cannot get the content of the response twice: buffering is disabled.');
  63.             }
  64.         } else {
  65.             foreach (self::stream([$this]) as $chunk) {
  66.                 // Chunks are buffered in $this->content already
  67.             }
  68.         }
  70.         rewind($this->content);
  72.         return stream_get_contents($this->content);
  73.     }
  75.     public function toArray(bool $throw = true): array
  76.     {
  77.         if ('' === $content = $this->getContent($throw)) {
  78.             throw new JsonException('Response body is empty.');
  79.         }
  81.         if (null !== $this->jsonData) {
  82.             return $this->jsonData;
  83.         }
  85.         try {
  86.             $content = json_decode($content, true, 512, \JSON_BIGINT_AS_STRING | \JSON_THROW_ON_ERROR);
  87.         } catch (\JsonException $e) {
  88.             throw new JsonException($e->getMessage().sprintf(' for "%s".', $this->getInfo('url')), $e->getCode());
  89.         }
  91.         if (!\is_array($content)) {
  92.             throw new JsonException(sprintf('JSON content was expected to decode to an array, "%s" returned for "%s".', get_debug_type($content), $this->getInfo('url')));
  93.         }
  95.         if (null !== $this->content) {
  96.             // Option "buffer" is true
  97.             return $this->jsonData = $content;
  98.         }
  100.         return $content;
  101.     }
  103.     public function toStream(bool $throw = true)
  104.     {
  105.         if ($throw) {
  106.             // Ensure headers arrived
  107.             $this->getHeaders($throw);
  108.         }
  110.         $stream = StreamWrapper::createResource($this);
  111.         stream_get_meta_data($stream)['wrapper_data']
  112.             ->bindHandles($this->handle, $this->content);
  114.         return $stream;
  115.     }
  117.     public function __sleep(): array
  118.     {
  119.         throw new \BadMethodCallException('Cannot serialize '.__CLASS__);
  120.     }
  122.     public function __wakeup()
  123.     {
  124.         throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
  125.     }
  127.     /**
  128.      * Closes the response and all its network handles.
  129.      */
  130.     abstract protected function close(): void;
  132.     private static function initialize(self $response): void
  133.     {
  134.         if (null !== $response->getInfo('error')) {
  135.             throw new TransportException($response->getInfo('error'));
  136.         }
  138.         try {
  139.             if (($response->initializer)($response, -0.0)) {
  140.                 foreach (self::stream([$response], -0.0) as $chunk) {
  141.                     if ($chunk->isFirst()) {
  142.                         break;
  143.                     }
  144.                 }
  145.             }
  146.         } catch (\Throwable $e) {
  147.             // Persist timeouts thrown during initialization
  148.             $response->info['error'] = $e->getMessage();
  149.             $response->close();
  150.             throw $e;
  151.         }
  153.         $response->initializer = null;
  154.     }
  156.     private function checkStatusCode()
  157.     {
  158.         $code = $this->getInfo('http_code');
  160.         if (500 <= $code) {
  161.             throw new ServerException($this);
  162.         }
  164.         if (400 <= $code) {
  165.             throw new ClientException($this);
  166.         }
  168.         if (300 <= $code) {
  169.             throw new RedirectionException($this);
  170.         }
  171.     }
  172. }