RedisConnRef.php

Go to the documentation of this file.

<?php
namespace Wikimedia\ObjectCache;
 
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerInterface;
use Redis;
use RedisException;
 
class RedisConnRef implements LoggerAwareInterface {
    protected $pool;
    protected $conn;
    protected $server;
    protected $lastError;
 
    protected $logger;
 
    private const AUTH_NO_ERROR = 200;
 
    private const AUTH_ERROR_TEMPORARY = 201;
 
    private const AUTH_ERROR_PERMANENT = 202;
 
    public function __construct(
        RedisConnectionPool $pool, $server, Redis $conn, LoggerInterface $logger
    ) {
        $this->pool = $pool;
        $this->server = $server;
        $this->conn = $conn;
        $this->logger = $logger;
    }
 
    public function setLogger( LoggerInterface $logger ): void {
        $this->logger = $logger;
    }
 
    public function getServer() {
        return $this->server;
    }
 
    public function getLastError() {
        return $this->lastError;
    }
 
    public function clearLastError() {
        $this->lastError = null;
    }
 
    public function __call( $name, $arguments ) {
        // Work around https://github.com/nicolasff/phpredis/issues/70
        $lname = strtolower( $name );
        if (
            ( $lname === 'blpop' || $lname === 'brpop' || $lname === 'brpoplpush' )
            && count( $arguments ) > 1
        ) {
            // Get timeout off the end since it is always required and argument length can vary
            $timeout = end( $arguments );
            // Only give the additional one second buffer if not requesting an infinite timeout
            $this->pool->resetTimeout( $this->conn, ( $timeout > 0 ? $timeout + 1 : $timeout ) );
        }
 
        return $this->tryCall( $name, $arguments );
    }
 
    private function tryCall( $method, $arguments ) {
        $this->conn->clearLastError();
        try {
            $res = $this->conn->$method( ...$arguments );
            $authError = $this->checkAuthentication();
            if ( $authError === self::AUTH_ERROR_TEMPORARY ) {
                $res = $this->conn->$method( ...$arguments );
            }
            if ( $authError === self::AUTH_ERROR_PERMANENT ) {
                throw new RedisException( "Failure reauthenticating to Redis." );
            }
            return $res;
        } finally {
            $this->postCallCleanup();
        }
    }
 
    public function scan( &$iterator, $pattern = null, $count = null ) {
        return $this->tryCall( 'scan', [ &$iterator, $pattern, $count ] );
    }
 
    public function sScan( $key, &$iterator, $pattern = null, $count = null ) {
        return $this->tryCall( 'sScan', [ $key, &$iterator, $pattern, $count ] );
    }
 
    public function hScan( $key, &$iterator, $pattern = null, $count = null ) {
        return $this->tryCall( 'hScan', [ $key, &$iterator, $pattern, $count ] );
    }
 
    public function zScan( $key, &$iterator, $pattern = null, $count = null ) {
        return $this->tryCall( 'zScan', [ $key, &$iterator, $pattern, $count ] );
    }
 
    private function checkAuthentication() {
        $lastError = $this->conn->getLastError();
        if ( $lastError && preg_match( '/^ERR operation not permitted\b/', $lastError ) ) {
            if ( !$this->pool->reauthenticateConnection( $this->server, $this->conn ) ) {
                return self::AUTH_ERROR_PERMANENT;
            }
            $this->conn->clearLastError();
            $this->logger->info(
                "Used automatic re-authentication for Redis.",
                [ 'redis_server' => $this->server ]
            );
            return self::AUTH_ERROR_TEMPORARY;
        }
        return self::AUTH_NO_ERROR;
    }
 
    private function postCallCleanup() {
        $this->lastError = $this->conn->getLastError() ?: $this->lastError;
 
        // Restore original timeout in the case of blocking calls.
        $this->pool->resetTimeout( $this->conn );
    }
 
    public function luaEval( $script, array $params, $numKeys ) {
        $sha1 = sha1( $script ); // 40 char hex
        $conn = $this->conn; // convenience
        $server = $this->server; // convenience
 
        // Try to run the server-side cached copy of the script
        $conn->clearLastError();
        $res = $conn->evalSha( $sha1, $params, $numKeys );
        // If we got a permission error reply that means that (a) we are not in
        // multi()/pipeline() and (b) some connection problem likely occurred. If
        // the password the client gave was just wrong, an exception should have
        // been thrown back in getConnection() previously.
        $lastError = $conn->getLastError();
        if ( $lastError && preg_match( '/^ERR operation not permitted\b/', $lastError ) ) {
            $this->pool->reauthenticateConnection( $server, $conn );
            $conn->clearLastError();
            $res = $conn->eval( $script, $params, $numKeys );
            $this->logger->info(
                "Used automatic re-authentication for Lua script '$sha1'.",
                [ 'redis_server' => $server ]
            );
        }
        // If the script is not in cache, use eval() to retry and cache it
        $lastError = $conn->getLastError();
        if ( $lastError && preg_match( '/^NOSCRIPT/', $lastError ) ) {
            $conn->clearLastError();
            $res = $conn->eval( $script, $params, $numKeys );
            $this->logger->info(
                "Used eval() for Lua script '$sha1'.",
                [ 'redis_server' => $server ]
            );
        }
 
        $lastError = $conn->getLastError();
        if ( $lastError ) { // script bug?
            $this->logger->error(
                'Lua script error on server "{redis_server}": {lua_error}',
                [
                    'redis_server' => $server,
                    'lua_error' => $lastError
                ]
            );
            $this->lastError = $lastError;
        }
 
        return $res;
    }
 
    public function isConnIdentical( Redis $conn ) {
        return $this->conn === $conn;
    }
 
    public function __destruct() {
        $this->pool->freeConnection( $this->server, $this->conn );
    }
}
 
class_alias( RedisConnRef::class, 'RedisConnRef' );