vendor/symfony/http-client/Response/TransportResponseTrait.php line 49

  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 Psr\Log\LoggerInterface;
  15. use Symfony\Component\HttpClient\Chunk\DataChunk;
  16. use Symfony\Component\HttpClient\Chunk\ErrorChunk;
  17. use Symfony\Component\HttpClient\Chunk\FirstChunk;
  18. use Symfony\Component\HttpClient\Chunk\LastChunk;
  19. use Symfony\Component\HttpClient\Exception\TransportException;
  20. use Symfony\Component\HttpClient\Internal\Canary;
  21. use Symfony\Component\HttpClient\Internal\ClientState;
  23. /**
  24.  * Implements common logic for transport-level response classes.
  25.  *
  26.  * @author Nicolas Grekas <p@tchwork.com>
  27.  *
  28.  * @internal
  29.  */
  30. trait TransportResponseTrait
  31. {
  32.     private Canary $canary;
  33.     private array $headers = [];
  34.     private array $info = [
  35.         'response_headers' => [],
  36.         'http_code' => 0,
  37.         'error' => null,
  38.         'canceled' => false,
  39.     ];
  41.     /** @var object|resource */
  42.     private $handle;
  43.     private int|string $id;
  44.     private ?float $timeout = 0;
  45.     private \InflateContext|bool|null $inflate = null;
  46.     private ?array $finalInfo = null;
  47.     private ?LoggerInterface $logger = null;
  49.     public function getStatusCode(): int
  50.     {
  51.         if ($this->initializer) {
  52.             self::initialize($this);
  53.         }
  55.         return $this->info['http_code'];
  56.     }
  58.     public function getHeaders(bool $throw = true): array
  59.     {
  60.         if ($this->initializer) {
  61.             self::initialize($this);
  62.         }
  64.         if ($throw) {
  65.             $this->checkStatusCode();
  66.         }
  68.         return $this->headers;
  69.     }
  71.     public function cancel(): void
  72.     {
  73.         $this->info['canceled'] = true;
  74.         $this->info['error'] = 'Response has been canceled.';
  75.         $this->close();
  76.     }
  78.     /**
  79.      * Closes the response and all its network handles.
  80.      */
  81.     protected function close(): void
  82.     {
  83.         $this->canary->cancel();
  84.         $this->inflate = null;
  85.     }
  87.     /**
  88.      * Adds pending responses to the activity list.
  89.      */
  90.     abstract protected static function schedule(self $response, array &$runningResponses): void;
  92.     /**
  93.      * Performs all pending non-blocking operations.
  94.      */
  95.     abstract protected static function perform(ClientState $multi, array &$responses): void;
  97.     /**
  98.      * Waits for network activity.
  99.      */
  100.     abstract protected static function select(ClientState $multi, float $timeout): int;
  102.     private static function addResponseHeaders(array $responseHeaders, array &$info, array &$headers, string &$debug = ''): void
  103.     {
  104.         foreach ($responseHeaders as $h) {
  105.             if (11 <= \strlen($h) && '/' === $h[4] && preg_match('#^HTTP/\d+(?:\.\d+)? (\d\d\d)(?: |$)#', $h, $m)) {
  106.                 if ($headers) {
  107.                     $debug .= "< \r\n";
  108.                     $headers = [];
  109.                 }
  110.                 $info['http_code'] = (int) $m[1];
  111.             } elseif (2 === \count($m = explode(':', $h, 2))) {
  112.                 $headers[strtolower($m[0])][] = ltrim($m[1]);
  113.             }
  115.             $debug .= "< {$h}\r\n";
  116.             $info['response_headers'][] = $h;
  117.         }
  119.         $debug .= "< \r\n";
  120.     }
  122.     /**
  123.      * Ensures the request is always sent and that the response code was checked.
  124.      */
  125.     private function doDestruct(): void
  126.     {
  127.         $this->shouldBuffer = true;
  129.         if ($this->initializer && null === $this->info['error']) {
  130.             self::initialize($this);
  131.             $this->checkStatusCode();
  132.         }
  133.     }
  135.     /**
  136.      * Implements an event loop based on a buffer activity queue.
  137.      *
  138.      * @param iterable<array-key, self> $responses
  139.      *
  140.      * @internal
  141.      */
  142.     public static function stream(iterable $responses, float $timeout = null): \Generator
  143.     {
  144.         $runningResponses = [];
  146.         foreach ($responses as $response) {
  147.             self::schedule($response, $runningResponses);
  148.         }
  150.         $lastActivity = microtime(true);
  151.         $elapsedTimeout = 0;
  153.         if ($fromLastTimeout = 0.0 === $timeout && '-0' === (string) $timeout) {
  154.             $timeout = null;
  155.         } elseif ($fromLastTimeout = 0 > $timeout) {
  156.             $timeout = -$timeout;
  157.         }
  159.         while (true) {
  160.             $hasActivity = false;
  161.             $timeoutMax = 0;
  162.             $timeoutMin = $timeout ?? \INF;
  164.             /** @var ClientState $multi */
  165.             foreach ($runningResponses as $i => [$multi]) {
  166.                 $responses = &$runningResponses[$i][1];
  167.                 self::perform($multi, $responses);
  169.                 foreach ($responses as $j => $response) {
  170.                     $timeoutMax = $timeout ?? max($timeoutMax, $response->timeout);
  171.                     $timeoutMin = min($timeoutMin, $response->timeout, 1);
  172.                     $chunk = false;
  174.                     if ($fromLastTimeout && null !== $multi->lastTimeout) {
  175.                         $elapsedTimeout = microtime(true) - $multi->lastTimeout;
  176.                     }
  178.                     if (isset($multi->handlesActivity[$j])) {
  179.                         $multi->lastTimeout = null;
  180.                     } elseif (!isset($multi->openHandles[$j])) {
  181.                         unset($responses[$j]);
  182.                         continue;
  183.                     } elseif ($elapsedTimeout >= $timeoutMax) {
  184.                         $multi->handlesActivity[$j] = [new ErrorChunk($response->offset, sprintf('Idle timeout reached for "%s".', $response->getInfo('url')))];
  185.                         $multi->lastTimeout ??= $lastActivity;
  186.                     } else {
  187.                         continue;
  188.                     }
  190.                     while ($multi->handlesActivity[$j] ?? false) {
  191.                         $hasActivity = true;
  192.                         $elapsedTimeout = 0;
  194.                         if (\is_string($chunk = array_shift($multi->handlesActivity[$j]))) {
  195.                             if (null !== $response->inflate && false === $chunk = @inflate_add($response->inflate, $chunk)) {
  196.                                 $multi->handlesActivity[$j] = [null, new TransportException(sprintf('Error while processing content unencoding for "%s".', $response->getInfo('url')))];
  197.                                 continue;
  198.                             }
  200.                             if ('' !== $chunk && null !== $response->content && \strlen($chunk) !== fwrite($response->content, $chunk)) {
  201.                                 $multi->handlesActivity[$j] = [null, new TransportException(sprintf('Failed writing %d bytes to the response buffer.', \strlen($chunk)))];
  202.                                 continue;
  203.                             }
  205.                             $chunkLen = \strlen($chunk);
  206.                             $chunk = new DataChunk($response->offset, $chunk);
  207.                             $response->offset += $chunkLen;
  208.                         } elseif (null === $chunk) {
  209.                             $e = $multi->handlesActivity[$j][0];
  210.                             unset($responses[$j], $multi->handlesActivity[$j]);
  211.                             $response->close();
  213.                             if (null !== $e) {
  214.                                 $response->info['error'] = $e->getMessage();
  216.                                 if ($e instanceof \Error) {
  217.                                     throw $e;
  218.                                 }
  220.                                 $chunk = new ErrorChunk($response->offset, $e);
  221.                             } else {
  222.                                 if (0 === $response->offset && null === $response->content) {
  223.                                     $response->content = fopen('php://memory', 'w+');
  224.                                 }
  226.                                 $chunk = new LastChunk($response->offset);
  227.                             }
  228.                         } elseif ($chunk instanceof ErrorChunk) {
  229.                             unset($responses[$j]);
  230.                             $elapsedTimeout = $timeoutMax;
  231.                         } elseif ($chunk instanceof FirstChunk) {
  232.                             if ($response->logger) {
  233.                                 $info = $response->getInfo();
  234.                                 $response->logger->info(sprintf('Response: "%s %s"', $info['http_code'], $info['url']));
  235.                             }
  237.                             $response->inflate = \extension_loaded('zlib') && $response->inflate && 'gzip' === ($response->headers['content-encoding'][0] ?? null) ? inflate_init(\ZLIB_ENCODING_GZIP) : null;
  239.                             if ($response->shouldBuffer instanceof \Closure) {
  240.                                 try {
  241.                                     $response->shouldBuffer = ($response->shouldBuffer)($response->headers);
  243.                                     if (null !== $response->info['error']) {
  244.                                         throw new TransportException($response->info['error']);
  245.                                     }
  246.                                 } catch (\Throwable $e) {
  247.                                     $response->close();
  248.                                     $multi->handlesActivity[$j] = [null, $e];
  249.                                 }
  250.                             }
  252.                             if (true === $response->shouldBuffer) {
  253.                                 $response->content = fopen('php://temp', 'w+');
  254.                             } elseif (\is_resource($response->shouldBuffer)) {
  255.                                 $response->content = $response->shouldBuffer;
  256.                             }
  257.                             $response->shouldBuffer = null;
  259.                             yield $response => $chunk;
  261.                             if ($response->initializer && null === $response->info['error']) {
  262.                                 // Ensure the HTTP status code is always checked
  263.                                 $response->getHeaders(true);
  264.                             }
  266.                             continue;
  267.                         }
  269.                         yield $response => $chunk;
  270.                     }
  272.                     unset($multi->handlesActivity[$j]);
  274.                     if ($chunk instanceof ErrorChunk && !$chunk->didThrow()) {
  275.                         // Ensure transport exceptions are always thrown
  276.                         $chunk->getContent();
  277.                     }
  278.                 }
  280.                 if (!$responses) {
  281.                     unset($runningResponses[$i]);
  282.                 }
  284.                 // Prevent memory leaks
  285.                 $multi->handlesActivity = $multi->handlesActivity ?: [];
  286.                 $multi->openHandles = $multi->openHandles ?: [];
  287.             }
  289.             if (!$runningResponses) {
  290.                 break;
  291.             }
  293.             if ($hasActivity) {
  294.                 $lastActivity = microtime(true);
  295.                 continue;
  296.             }
  298.             if (-1 === self::select($multi, min($timeoutMin, $timeoutMax - $elapsedTimeout))) {
  299.                 usleep(min(500, 1E6 * $timeoutMin));
  300.             }
  302.             $elapsedTimeout = microtime(true) - $lastActivity;
  303.         }
  304.     }
  305. }