Monospice\LaravelRedisSentinel\Connections\PhpRedisConnection

Complexity

Total Complexity

14

Size/Duplication

Total Lines	197
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	scan()	0	6	1
A	zscan()	0	6	1
A	hscan()	0	6	1
A	sscan()	0	6	1
A	pipeline()	0	6	1
A	transaction()	0	6	1
A	subscribe()	0	6	1
A	psubscribe()	0	6	1
A	command()	0	6	1
A	retryOnFailure()	0	25	4

<?php

namespace Monospice\LaravelRedisSentinel\Connections;

use Closure;
use Illuminate\Redis\Connections\PhpRedisConnection as LaravelPhpRedisConnection;
use Redis;
use RedisException;

/**
 * Executes Redis commands using the PhpRedis client.
 *
 * This package extends Laravel's PhpRedisConnection class to wrap all command
 * methods with a retryOnFailure method.
 *
 * @category Package
 * @package  Monospice\LaravelRedisSentinel
 * @author   Jeffrey Zant <j.zant@slash2.nl>
 * @license  See LICENSE file
 * @link     https://github.com/monospice/laravel-redis-sentinel-drivers
 */
class PhpRedisConnection extends LaravelPhpRedisConnection
{
    /**
     * The number of times the client attempts to retry a command when it fails
     * to connect to a Redis instance behind Sentinel.
     *
     * @var int
     */
    protected $retryLimit = 20;

    /**
     * The time in milliseconds to wait before the client retries a failed
     * command.
     *
     * @var int
     */
    protected $retryWait = 1000;

    /**
     * Create a new PhpRedis connection.
     *
     * @param  \Redis  $client
     * @param  callable|null  $connector
     * @param  array  $sentinelOptions
     * @return void

Adding a @return annotation to constructors is generally not recommended as a constructor does not have a meaningful return value.

     */
    public function __construct($client, callable $connector = null, array $sentinelOptions = [])
    {
        parent::__construct($client, $connector);

        $this->retryLimit = (int) ($sentinelOptions['retry_limit'] ?? 20);
        $this->retryWait = (int) ($sentinelOptions['retry_wait'] ?? 1000);
    }

    /**
     * {@inheritdoc} in addition retry on client failure.
     *
     * @param  mixed  $cursor
     * @param  array  $options
     * @return mixed
     */
    public function scan($cursor, $options = [])
    {
        return $this->retryOnFailure(function () use ($cursor, $options) {
            return parent::scan($cursor, $options);
        });
    }

    /**
     * {@inheritdoc} in addition retry on client failure.
     *
     * @param  string  $key
     * @param  mixed  $cursor
     * @param  array  $options
     * @return mixed
     */
    public function zscan($key, $cursor, $options = [])
    {
        return $this->retryOnFailure(function () use ($key, $cursor, $options) {
            parent::zscan($key, $cursor, $options);
        });
    }

    /**
     * {@inheritdoc} in addition retry on client failure.
     *
     * @param  string  $key
     * @param  mixed  $cursor
     * @param  array  $options
     * @return mixed
     */
    public function hscan($key, $cursor, $options = [])
    {
        return $this->retryOnFailure(function () use ($key, $cursor, $options) {
            parent::hscan($key, $cursor, $options);
        });
    }

    /**
     * {@inheritdoc} in addition retry on client failure.
     *
     * @param  string  $key
     * @param  mixed  $cursor
     * @param  array  $options
     * @return mixed
     */
    public function sscan($key, $cursor, $options = [])
    {
        return $this->retryOnFailure(function () use ($key, $cursor, $options) {
            parent::sscan($key, $cursor, $options);
        });
    }

    /**
     * {@inheritdoc} in addition retry on client failure.
     *
     * @param  callable|null  $callback
     * @return \Redis|array
     */
    public function pipeline(callable $callback = null)
    {
        return $this->retryOnFailure(function () use ($callback) {
            return parent::pipeline($callback);
        });
    }

    /**
     * {@inheritdoc} in addition retry on client failure.
     *
     * @param  callable|null  $callback
     * @return \Redis|array
     */
    public function transaction(callable $callback = null)
    {
        return $this->retryOnFailure(function () use ($callback) {
            return parent::transaction($callback);
        });
    }

    /**
     * {@inheritdoc} in addition retry on client failure.
     *
     * @param  array|string  $channels
     * @param  \Closure  $callback
     * @return void
     */
    public function subscribe($channels, Closure $callback)
    {
        return $this->retryOnFailure(function () use ($channels, $callback) {
            return parent::subscribe($channels, $callback);
        });
    }

    /**
     * {@inheritdoc} in addition retry on client failure.
     *
     * @param  array|string  $channels
     * @param  \Closure  $callback
     * @return void
     */
    public function psubscribe($channels, Closure $callback)
    {
        return $this->retryOnFailure(function () use ($channels, $callback) {
            return parent::psubscribe($channels, $callback);
        });
    }

    /**
     * {@inheritdoc} in addition retry on client failure.
     *
     * @param  string  $method
     * @param  array  $parameters
     * @return mixed
     */
    public function command($method, array $parameters = [])
    {
        return $this->retryOnFailure(function () use ($method, $parameters) {
            return parent::command($method, $parameters);
        });
    }

    /**
     * Attempt to retry the provided operation when the client fails to connect
     * to a Redis server.
     *
     * @param callable $callback The operation to execute.
     * @return mixed The result of the first successful attempt.
     *
     * @throws RedisException After exhausting the allowed number of
     * attempts to reconnect.
     */
    protected function retryOnFailure(callable $callback)
    {
        $attempts = 0;

        do {
            try {
                return $callback();
            } catch (RedisException $exception) {
                $this->client->close();

                usleep($this->retryWait * 1000);

                try {
                    $this->client = $this->connector();

The method connector does not exist on object<Monospice\LaravelRedisSentinel\Connections\PhpRedisConnection>? Since you implemented __call, maybe consider adding a @method annotation.

                } catch (RedisException $e) {
                    // Ignore the the creation of a new client gets an exception.
                    // If this exception isn't caught the retry will stop.
                }

                $attempts++;
            }
        } while ($attempts <= $this->retryLimit);

        throw $exception;
    }
}