vendor/symfony/http-client/Response/TraceableResponse.php line 103

  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\ErrorChunk;
  15. use Symfony\Component\HttpClient\Exception\ClientException;
  16. use Symfony\Component\HttpClient\Exception\RedirectionException;
  17. use Symfony\Component\HttpClient\Exception\ServerException;
  18. use Symfony\Component\HttpClient\TraceableHttpClient;
  19. use Symfony\Component\Stopwatch\StopwatchEvent;
  20. use Symfony\Contracts\HttpClient\Exception\ClientExceptionInterface;
  21. use Symfony\Contracts\HttpClient\Exception\RedirectionExceptionInterface;
  22. use Symfony\Contracts\HttpClient\Exception\ServerExceptionInterface;
  23. use Symfony\Contracts\HttpClient\Exception\TransportExceptionInterface;
  24. use Symfony\Contracts\HttpClient\HttpClientInterface;
  25. use Symfony\Contracts\HttpClient\ResponseInterface;
  27. /**
  28.  * @author Nicolas Grekas <p@tchwork.com>
  29.  *
  30.  * @internal
  31.  */
  32. class TraceableResponse implements ResponseInterface, StreamableInterface
  33. {
  34.     private HttpClientInterface $client;
  35.     private ResponseInterface $response;
  36.     private mixed $content;
  37.     private ?StopwatchEvent $event;
  39.     public function __construct(HttpClientInterface $client, ResponseInterface $response, &$content, StopwatchEvent $event = null)
  40.     {
  41.         $this->client = $client;
  42.         $this->response = $response;
  43.         $this->content = &$content;
  44.         $this->event = $event;
  45.     }
  47.     public function __sleep(): array
  48.     {
  49.         throw new \BadMethodCallException('Cannot serialize '.__CLASS__);
  50.     }
  52.     public function __wakeup()
  53.     {
  54.         throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
  55.     }
  57.     public function __destruct()
  58.     {
  59.         try {
  60.             $this->response->__destruct();
  61.         } finally {
  62.             if ($this->event?->isStarted()) {
  63.                 $this->event->stop();
  64.             }
  65.         }
  66.     }
  68.     public function getStatusCode(): int
  69.     {
  70.         try {
  71.             return $this->response->getStatusCode();
  72.         } finally {
  73.             if ($this->event?->isStarted()) {
  74.                 $this->event->lap();
  75.             }
  76.         }
  77.     }
  79.     public function getHeaders(bool $throw = true): array
  80.     {
  81.         try {
  82.             return $this->response->getHeaders($throw);
  83.         } finally {
  84.             if ($this->event?->isStarted()) {
  85.                 $this->event->lap();
  86.             }
  87.         }
  88.     }
  90.     public function getContent(bool $throw = true): string
  91.     {
  92.         try {
  93.             if (false === $this->content) {
  94.                 return $this->response->getContent($throw);
  95.             }
  97.             return $this->content = $this->response->getContent(false);
  98.         } finally {
  99.             if ($this->event?->isStarted()) {
  100.                 $this->event->stop();
  101.             }
  102.             if ($throw) {
  103.                 $this->checkStatusCode($this->response->getStatusCode());
  104.             }
  105.         }
  106.     }
  108.     public function toArray(bool $throw = true): array
  109.     {
  110.         try {
  111.             if (false === $this->content) {
  112.                 return $this->response->toArray($throw);
  113.             }
  115.             return $this->content = $this->response->toArray(false);
  116.         } finally {
  117.             if ($this->event?->isStarted()) {
  118.                 $this->event->stop();
  119.             }
  120.             if ($throw) {
  121.                 $this->checkStatusCode($this->response->getStatusCode());
  122.             }
  123.         }
  124.     }
  126.     public function cancel(): void
  127.     {
  128.         $this->response->cancel();
  130.         if ($this->event?->isStarted()) {
  131.             $this->event->stop();
  132.         }
  133.     }
  135.     public function getInfo(string $type = null): mixed
  136.     {
  137.         return $this->response->getInfo($type);
  138.     }
  140.     /**
  141.      * Casts the response to a PHP stream resource.
  142.      *
  143.      * @return resource
  144.      *
  145.      * @throws TransportExceptionInterface   When a network error occurs
  146.      * @throws RedirectionExceptionInterface On a 3xx when $throw is true and the "max_redirects" option has been reached
  147.      * @throws ClientExceptionInterface      On a 4xx when $throw is true
  148.      * @throws ServerExceptionInterface      On a 5xx when $throw is true
  149.      */
  150.     public function toStream(bool $throw = true)
  151.     {
  152.         if ($throw) {
  153.             // Ensure headers arrived
  154.             $this->response->getHeaders(true);
  155.         }
  157.         if ($this->response instanceof StreamableInterface) {
  158.             return $this->response->toStream(false);
  159.         }
  161.         return StreamWrapper::createResource($this->response, $this->client);
  162.     }
  164.     /**
  165.      * @internal
  166.      */
  167.     public static function stream(HttpClientInterface $client, iterable $responses, ?float $timeout): \Generator
  168.     {
  169.         $wrappedResponses = [];
  170.         $traceableMap = new \SplObjectStorage();
  172.         foreach ($responses as $r) {
  173.             if (!$r instanceof self) {
  174.                 throw new \TypeError(sprintf('"%s::stream()" expects parameter 1 to be an iterable of TraceableResponse objects, "%s" given.', TraceableHttpClient::class, get_debug_type($r)));
  175.             }
  177.             $traceableMap[$r->response] = $r;
  178.             $wrappedResponses[] = $r->response;
  179.             if ($r->event && !$r->event->isStarted()) {
  180.                 $r->event->start();
  181.             }
  182.         }
  184.         foreach ($client->stream($wrappedResponses, $timeout) as $r => $chunk) {
  185.             if ($traceableMap[$r]->event && $traceableMap[$r]->event->isStarted()) {
  186.                 try {
  187.                     if ($chunk->isTimeout() || !$chunk->isLast()) {
  188.                         $traceableMap[$r]->event->lap();
  189.                     } else {
  190.                         $traceableMap[$r]->event->stop();
  191.                     }
  192.                 } catch (TransportExceptionInterface $e) {
  193.                     $traceableMap[$r]->event->stop();
  194.                     if ($chunk instanceof ErrorChunk) {
  195.                         $chunk->didThrow(false);
  196.                     } else {
  197.                         $chunk = new ErrorChunk($chunk->getOffset(), $e);
  198.                     }
  199.                 }
  200.             }
  201.             yield $traceableMap[$r] => $chunk;
  202.         }
  203.     }
  205.     private function checkStatusCode(int $code): void
  206.     {
  207.         if (500 <= $code) {
  208.             throw new ServerException($this);
  209.         }
  211.         if (400 <= $code) {
  212.             throw new ClientException($this);
  213.         }
  215.         if (300 <= $code) {
  216.             throw new RedirectionException($this);
  217.         }
  218.     }
  219. }