WIP Add 429 response handler

.gitignore

@@ -81,3 +81,4 @@ tmp/
 
 # PhpCs
 .php_cs*
+.idea

development/Dockerfile

@@ -0,0 +1,20 @@
+FROM php:7.2-cli
+
+RUN apt-get update -yqq \
+ && apt-get install -yqq \
+    # install ping and netcat (for debugging xdebug connectivity)
+    iputils-ping netcat \
+    wget \
+;
+RUN  pecl config-set php_ini /usr/local/etc/php/php.ini \
+    && pecl install xdebug
+COPY ./development/php.ini /usr/local/etc/php/php.ini
+
+RUN wget https://phar.phpunit.de/phpunit-6.5.phar \
+    && chmod +x phpunit-6.5.phar \
+    && mv phpunit-6.5.phar /usr/local/bin/phpunit \
+    && phpunit --version
+
+EXPOSE 9000
+
+CMD ["bin/sh"]

development/php.ini

@@ -0,0 +1 @@
+zend_extension=/usr/local/lib/php/extensions/no-debug-non-zts-20170718/xdebug.so

docker-compose.yaml

@@ -0,0 +1,12 @@
+version: "3"
+
+services:
+
+  php_dev:
+    # this service can be used to develop with docker image in phpstorm
+    # this way you do not need to install php on your system
+    build:
+      context: ./
+      dockerfile: ./development/Dockerfile
+    volumes:
+      - .:/var/www/app:rw

src/Http/ApiClient.php

@@ -9,17 +9,19 @@
 use bunq\Http\Handler\RequestHandlerEncryption;
 use bunq\Http\Handler\RequestHandlerSignature;
 use bunq\Http\Handler\ResponseHandlerError;
+use bunq\Http\Handler\ResponseHandlerRateLimit;
 use bunq\Http\Handler\ResponseHandlerSignature;
 use bunq\Util\BunqEnumApiEnvironmentType;
 use GuzzleHttp\Client;
 use GuzzleHttp\Exception\RequestException;
 use GuzzleHttp\HandlerStack;
 use GuzzleHttp\Psr7\Uri;
+use Psr\Http\Message\RequestInterface;
 use Psr\Http\Message\ResponseInterface;
 
 /**
  */
-class ApiClient
+class ApiClient implements RequestRetryer
 {
     /**
      * Error constants.
@@ -235,6 +237,28 @@ private function request(
         return $this->createBunqResponseRaw($response);
     }
 
+    /**
+     * @param RequestInterface $request
+     * @return ResponseInterface
+     */
+    public function retryRequest(RequestInterface $request): ResponseInterface
+    {
+        $this->initialize($request->getUri());
+
+        if ($request->getBody()->isSeekable()) {
+            $request->getBody()->rewind();
+        }
+
+        return $this->httpClient->request(
+            $request->getMethod(),
+            $request->getUri(),
+            $this->determineRequestOptions(
+                $request->getBody()->getContents(),
+                $request->getHeaders()
+            )
+        );
+    }
+
     /**
      */
     private function initialize(string $uri)
@@ -298,6 +322,7 @@ private function determineMiddleware(): HandlerStack
         }
 
         $handlerStack->push(HandlerUtil::applyResponseHandler(new ResponseHandlerError()));
+        $handlerStack->push(HandlerUtil::applyResponseHandler(new ResponseHandlerRateLimit($this)));
 
         return $handlerStack;
     }
@@ -398,13 +423,17 @@ protected function determineBodyString($body): string
     {
         if ($this->isBinary) {
             return $body;
-        } elseif (empty($body)) {
+        }
+
+        if (empty($body)) {
             return self::BODY_EMPTY;
-        } else {
-            $bodyString = json_encode($body);
         }
 
-        return $bodyString;
+        if (is_array($body)) {
+            return json_encode($body);
+        }
+
+        return $body;
     }
 
     /**

src/Http/Handler/HandlerUtil.php

@@ -38,8 +38,8 @@ public static function applyResponseHandler(ResponseHandlerBase $responseHandler
         return function (callable $handler) use ($responseHandler) {
             return function (RequestInterface $request, array $options) use ($handler, $responseHandler) {
                 return $handler($request, $options)->then(
-                    function (ResponseInterface $response) use ($responseHandler) {
-                        return $responseHandler->execute($response);
+                    function (ResponseInterface $response) use ($responseHandler, $request) {
+                        return $responseHandler->execute($response, $request);
                     }
                 );
             };

src/Http/Handler/ResponseHandlerBase.php

@@ -1,6 +1,7 @@
 <?php
 namespace bunq\Http\Handler;
 
+use Psr\Http\Message\RequestInterface;
 use Psr\Http\Message\ResponseInterface;
 
 /**
@@ -9,8 +10,9 @@ abstract class ResponseHandlerBase extends HandlerBase
 {
     /**
      * @param ResponseInterface $response
+     * @param RequestInterface $request
      *
      * @return ResponseInterface
      */
-    abstract public function execute(ResponseInterface $response): ResponseInterface;
+    abstract public function execute(ResponseInterface $response, RequestInterface $request): ResponseInterface;
 }

src/Http/Handler/ResponseHandlerError.php

@@ -5,6 +5,7 @@
 use bunq\Exception\ApiException;
 use bunq\Exception\BunqException;
 use bunq\Exception\ExceptionFactory;
+use Psr\Http\Message\RequestInterface;
 use Psr\Http\Message\ResponseInterface;
 
 /**
@@ -41,11 +42,13 @@ class ResponseHandlerError extends ResponseHandlerBase
 
     /**
      * @param ResponseInterface $response
+     * @param RequestInterface $request
      *
      * @return ResponseInterface
      * @throws ApiException when something goes wrong on the API side.
+     * @throws BunqException
      */
-    public function execute(ResponseInterface $response): ResponseInterface
+    public function execute(ResponseInterface $response, RequestInterface $request): ResponseInterface
     {
         if ($response->getStatusCode() !== self::STATUS_CODE_OK) {
             throw ExceptionFactory::createExceptionForResponse(

src/Http/Handler/ResponseHandlerRateLimit.php

@@ -0,0 +1,69 @@
+<?php
+declare(strict_types=1);
+
+namespace bunq\Http\Handler;
+
+use bunq\Http\RequestRetryer;
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\ResponseInterface;
+
+/**
+ * Class ResponseHandlerRateLimit
+ * @package bunq\Http\Handler
+ */
+class ResponseHandlerRateLimit extends ResponseHandlerBase
+{
+    /**
+     * @var RequestRetryer
+     */
+    private $retryer;
+
+    /**
+     * @var string[]
+     */
+    private $retryMap;
+
+    /**
+     * ResponseHandlerRateLimit constructor.
+     * @param RequestRetryer $retryer
+     */
+    public function __construct(RequestRetryer $retryer)
+    {
+        $this->retryer = $retryer;
+    }
+
+    /**
+     * @param ResponseInterface $response
+     * @param RequestInterface $request
+     *
+     * @return ResponseInterface
+     */
+    public function execute(ResponseInterface $response, RequestInterface $request): ResponseInterface
+    {
+        if ($response->getStatusCode() === 429) {
+            $this->incRetryCounter($request->getUri()->__toString());
+            if ($this->retryMap[$request->getUri()->__toString()] > 2) {
+                // let the error handler further down the stack handle the 429 error
+                return $response;
+            }
+            usleep(1100 * $this->retryMap[$request->getUri()->__toString()]);
+            return $this->retryer->retryRequest($request);
+        }
+
+        $this->retryMap[$request->getUri()->__toString()] = 0;
+
+        return $response;
+    }
+
+    /**
+     * @param string $url
+     */
+    private function incRetryCounter(string $url)
+    {
+        if (isset($this->retryMap[$url])) {
+            $this->retryMap[$url]++;
+        } else {
+            $this->retryMap[$url] = 1;
+        }
+    }
+}

src/Http/Handler/ResponseHandlerSignature.php

@@ -3,6 +3,7 @@
 
 use bunq\Exception\SecurityException;
 use bunq\Security\PublicKey;
+use Psr\Http\Message\RequestInterface;
 use Psr\Http\Message\ResponseInterface;
 
 /**
@@ -61,11 +62,12 @@ public function __construct(PublicKey $publicKeyServer = null)
 
     /**
      * @param ResponseInterface $response
+     * @param RequestInterface $request
      *
      * @return ResponseInterface
      * @throws SecurityException when the response verification fails.
      */
-    public function execute(ResponseInterface $response): ResponseInterface
+    public function execute(ResponseInterface $response, RequestInterface $request): ResponseInterface
     {
         if ($response->getStatusCode() === self::STATUS_CODE_OK) {
             if (is_null($this->publicKeyServer)) {

src/Http/RequestRetryer.php

@@ -0,0 +1,19 @@
+<?php declare(strict_types=1);
+
+namespace bunq\Http;
+
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\ResponseInterface;
+
+/**
+ * Interface RequestRertier
+ * @package bunq\Http
+ */
+interface RequestRetryer
+{
+    /**
+     * @param RequestInterface $request
+     * @return ResponseInterface
+     */
+    public function retryRequest(RequestInterface $request): ResponseInterface;
+}

tests/Http/RequestRertyerForTest.php

@@ -0,0 +1,60 @@
+<?php
+declare(strict_types=1);
+
+
+namespace bunq\test\Http;
+
+use bunq\Http\RequestRetryer;
+use GuzzleHttp\Psr7\Response;
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\ResponseInterface;
+
+/**
+ * Class RequesRertyerForTest
+ * @package bunq\test\Http
+ */
+class RequestRertyerForTest implements RequestRetryer
+{
+    /**
+     * @var bool
+     */
+    private $retry;
+
+    /**
+     * @var int
+     */
+    private $calledCounter = 0;
+
+    /**
+     * RequestRertyerForTest constructor.
+     * @param bool $retry
+     */
+    public function __construct(bool $retry = false)
+    {
+        $this->retry = $retry;
+    }
+
+    /**
+     * @param RequestInterface $request
+     * @return ResponseInterface
+     */
+    public function retryRequest(RequestInterface $request): ResponseInterface
+    {
+        $this->calledCounter++;
+
+        if ($this->retry) {
+            $this->retry = false;
+            return $this->retryRequest($request);
+        }
+
+        return new Response();
+    }
+
+    /**
+     * @return int
+     */
+    public function getCalledCounter(): int
+    {
+        return $this->calledCounter;
+    }
+}