Use php://temp stream wrapper for storing responses

Author: SharkMachine

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 Semantic versioning 2.0 is followed.
 
+# 1.1.0
+
+- Use php://temp stream wrapper for storing responses
+
 # 1.0.1
 
 - Streamed response body and headers were not cleared for every request

src/Client.php

@@ -12,6 +12,7 @@
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\StreamFactoryInterface;
 use Psr\Http\Message\UriInterface;
+use SharkMachine\Psr18Shark\Exception\ClientException;
 use SharkMachine\Psr18Shark\Exception\CurlException;
 use SharkMachine\Psr18Shark\Exception\NoResponseException;
 use SharkMachine\Psr18Shark\Handler\RequestMutationHandlerCollection;
@@ -28,16 +29,6 @@ class Client implements ClientInterface
      */
     private CurlHandle $curl;
 
-    /**
-     * @var string
-     */
-    private string $dataStream = '';
-
-    /**
-     * @var array<string, string[]>
-     */
-    private array $responseHeaders = [];
-
     /**
      * @param ResponseFactoryInterface               $responseFactory
      * @param StreamFactoryInterface                 $streamFactory
@@ -79,10 +70,10 @@ public function sendRequest(RequestInterface $request): ResponseInterface
             }
         }
 
-        $this->initCurl($request->getUri());
         try {
-            $this->curlRequest($request);
-            $response = $this->getResponse();
+            $responseData = $this->initCurl($request->getUri());
+            $this->curlRequest($request, $responseData);
+            $response = $this->getResponse($responseData);
         } catch (Throwable $ex) {
             curl_close($this->curl);
             if (null !== $this->transferHandlerCollection) {
@@ -111,11 +102,18 @@ public function sendRequest(RequestInterface $request): ResponseInterface
     /**
      * @param UriInterface $uri
      *
-     * @return void
+     * @return ResponseData
+     *
+     * @throws ClientException
      */
-    protected function initCurl(UriInterface $uri): void
+    protected function initCurl(UriInterface $uri): ResponseData
     {
         $this->curl = curl_init((string)$uri);
+        $dataStream = fopen('php://temp', 'wb+');
+        if (false === $dataStream) {
+            throw new ClientException('Unable to open handle for response');
+        }
+        $responseData = new ResponseData($dataStream);
 
         // Do not follow redirects.
         curl_setopt($this->curl, CURLOPT_FOLLOWLOCATION, false);
@@ -124,28 +122,31 @@ protected function initCurl(UriInterface $uri): void
         curl_setopt(
             $this->curl,
             CURLOPT_WRITEFUNCTION,
-            function (CurlHandle $curl, string $data): int {
-                $this->dataStream .= $data;
-                return strlen($data);
+            static function (CurlHandle $curl, string $data) use ($responseData): int {
+                $bytes = fwrite($responseData->streamHandle, $data);
+                if (false === $bytes) {
+                    return -1; // This will cause a cURL error
+                }
+                return $bytes;
             }
         );
 
         // Get headers
         curl_setopt(
             $this->curl,
             CURLOPT_HEADERFUNCTION,
-            function (CurlHandle $curl, string $header): int {
+            static function (CurlHandle $curl, string $header) use ($responseData): int {
                 $len = strlen($header);
                 $headerArray = explode(':', $header, 2);
                 if (count($headerArray) < 2) {
                     return $len;
                 }
                 $headerName = strtolower(trim($headerArray[0]));
                 if (!str_contains($headerArray[1], ',')) {
-                    $this->responseHeaders[$headerName] = [trim($headerArray[1])];
+                    $responseData->headers[$headerName] = [trim($headerArray[1])];
                     return $len;
                 }
-                $this->responseHeaders[$headerName] = array_map(
+                $responseData->headers[$headerName] = array_map(
                     'trim',
                     explode(',', $headerArray[1])
                 );
@@ -175,20 +176,20 @@ function (CurlHandle $curl, string $header): int {
         if (!in_array(CURLOPT_USERAGENT, $this->curlOptions, true)) {
             curl_setopt($this->curl, CURLOPT_USERAGENT, self::DEFAULT_USER_AGENT);
         }
+
+        return $responseData;
     }
 
     /**
      * @param RequestInterface $request
+     * @param ResponseData     $responseData
      *
-     * @return void
+     * @return ResponseData
      *
      * @throws ClientExceptionInterface
      */
-    protected function curlRequest(RequestInterface $request): void
+    protected function curlRequest(RequestInterface $request, ResponseData $responseData): ResponseData
     {
-        $this->dataStream      = '';
-        $this->responseHeaders = [];
-
         if (count($request->getHeaders()) > 0) {
             $headers = [];
             foreach ($request->getHeaders() as $headerName => $headerValues) {
@@ -209,19 +210,23 @@ protected function curlRequest(RequestInterface $request): void
         if (false === curl_exec($this->curl)) {
             throw new CurlException(curl_error($this->curl));
         }
+        return $responseData;
     }
 
     /**
+     * @param ResponseData $responseData
+     *
      * @return ResponseInterface
      */
-    protected function getResponse(): ResponseInterface
+    protected function getResponse(ResponseData $responseData): ResponseInterface
     {
         $statusCode = curl_getinfo($this->curl, CURLINFO_HTTP_CODE);
         $response   = $this->responseFactory->createResponse($statusCode);
-        $response   = $response->withBody($this->streamFactory->createStream($this->dataStream));
-        foreach ($this->responseHeaders as $headerName => $headerValue) {
+        $response   = $response->withBody($this->streamFactory->createStreamFromResource($responseData->streamHandle));
+        foreach ($responseData->headers as $headerName => $headerValue) {
             $response = $response->withHeader($headerName, $headerValue);
         }
+        $response->getBody()->rewind();
         if (null !== $this->responseMutationHandlerCollection) {
             foreach ($this->responseMutationHandlerCollection as $handler) {
                 $response = $handler->handleResponse($response);

src/Exception/ClientException.php

@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SharkMachine\Psr18Shark\Exception;
+
+use Exception;
+use Psr\Http\Client\ClientExceptionInterface;
+
+final class ClientException extends Exception implements ClientExceptionInterface
+{
+}

src/ResponseData.php

@@ -0,0 +1,17 @@
+<?php
+declare(strict_types=1);
+
+namespace SharkMachine\Psr18Shark;
+
+class ResponseData
+{
+    /**
+     * @param resource                $streamHandle
+     * @param array<string, string[]> $headers
+     */
+    public function __construct(
+        public $streamHandle,
+        public array $headers = []
+    ) {
+    }
+}