Http\Client\Common\Plugin\RetryPlugin

Complexity

Total Complexity

7

Size/Duplication

Total Lines	121
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

95.35%

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	19	1
B	handleRequest()	0	51	5
A	defaultDelay()	0	4	1

<?php

namespace Http\Client\Common\Plugin;

use Http\Client\Common\Deferred;
use Http\Client\Common\Plugin;
use Http\Client\Exception;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;

/**
 * Retry the request if an exception is thrown.
 *
 * By default will retry only one time.
 *
 * @author Joel Wurtz <joel.wurtz@gmail.com>
 */
final class RetryPlugin implements Plugin
{
    /**
     * Number of retry before sending an exception.
     *
     * @var int
     */
    private $retry;

    /**
     * @var callable
     */
    private $delay;

    /**
     * @var callable
     */
    private $decider;

    /**
     * Store the retry counter for each request.
     *
     * @var array
     */
    private $retryStorage = [];

    /**
     * @param array $config {
     *
     *     @var int $retries Number of retries to attempt if an exception occurs before letting the exception bubble up.
     *     @var callable $decider A callback that gets a request and an exception to decide after a failure whether the request should be retried.
     *     @var callable $delay A callback that gets a request, an exception and the number of retries and returns how many microseconds we should wait before trying again.
     * }
     */
    public function __construct(array $config = [])
    {
        $resolver = new OptionsResolver();
        $resolver->setDefaults([
            'retries' => 1,
            'decider' => function (RequestInterface $request, Exception $e) {

The parameter $request is not used and could be removed.

The parameter $e is not used and could be removed.

                return true;
            },
            'delay' => __CLASS__.'::defaultDelay',
        ]);
        $resolver->setAllowedTypes('retries', 'int');
        $resolver->setAllowedTypes('decider', 'callable');
        $resolver->setAllowedTypes('delay', 'callable');
        $options = $resolver->resolve($config);

        $this->retry = $options['retries'];
        $this->decider = $options['decider'];
        $this->delay = $options['delay'];
    }

    /**
     * {@inheritdoc}
     */
    public function handleRequest(RequestInterface $request, callable $next, callable $first)
    {
        $chainIdentifier = spl_object_hash((object) $first);

        $promise = $next($request);
        $deferred = new Deferred(function () use ($promise) {
            $promise->wait(false);
        });

        $onFulfilled = function (ResponseInterface $response) use ($chainIdentifier, $deferred) {
            if (array_key_exists($chainIdentifier, $this->retryStorage)) {
                unset($this->retryStorage[$chainIdentifier]);
            }

            $deferred->resolve($response);

            return $response;
        };

        $onRejected = function (Exception $exception) use ($request, $next, $onFulfilled, &$onRejected, $chainIdentifier, $deferred) {
            if (!array_key_exists($chainIdentifier, $this->retryStorage)) {
                $this->retryStorage[$chainIdentifier] = 0;
            }

            if ($this->retryStorage[$chainIdentifier] >= $this->retry) {
                unset($this->retryStorage[$chainIdentifier]);

                $deferred->reject($exception);

                throw $exception;
            }

            if (!call_user_func($this->decider, $request, $exception)) {
                throw $exception;
            }

            $time = call_user_func($this->delay, $request, $exception, $this->retryStorage[$chainIdentifier]);
            usleep($time);

            // Retry in synchrone
            ++$this->retryStorage[$chainIdentifier];

            $next($request)->then($onFulfilled, $onRejected);

            throw $exception;
        };

        $promise->then($onFulfilled, $onRejected);

        return $deferred;
    }

    /**
     * @param RequestInterface $request
     * @param Exception        $e
     * @param int              $retries The number of retries we made before. First time this get called it will be 0.
     *
     * @return int
     */
    public static function defaultDelay(RequestInterface $request, Exception $e, $retries)

The parameter $request is not used and could be removed.

The parameter $e is not used and could be removed.

    {
        return pow(2, $retries) * 500000;
    }
}