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

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