includes/libs/redis/RedisConnRef.php

   1 <?php
   2 /**
   3  * This program is free software; you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation; either version 2 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along
  14  * with this program; if not, write to the Free Software Foundation, Inc.,
  15  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  16  * http://www.gnu.org/copyleft/gpl.html
  17  *
  18  * @file
  19  */
  20 use Psr\Log\LoggerInterface;
  21 use Psr\Log\LoggerAwareInterface;
  22
  23 /**
  24  * Helper class to handle automatically marking connectons as reusable (via RAII pattern)
  25  *
  26  * This class simply wraps the Redis class and can be used the same way
  27  *
  28  * @ingroup Redis
  29  * @since 1.21
  30  */
  31 class RedisConnRef implements LoggerAwareInterface {
  32         /** @var RedisConnectionPool */
  33         protected $pool;
  34         /** @var Redis */
  35         protected $conn;
  36         /** @var string */
  37         protected $server;
  38         /** @var string|null */
  39         protected $lastError;
  40
  41         /**
  42          * @var LoggerInterface
  43          */
  44         protected $logger;
  45
  46         /**
  47          * No authentication errors.
  48          */
  49         const AUTH_NO_ERROR = 200;
  50
  51         /**
  52          * Temporary authentication error; recovered by reauthenticating.
  53          */
  54         const AUTH_ERROR_TEMPORARY = 201;
  55
  56         /**
  57          * Authentication error was permanent and could not be recovered.
  58          */
  59         const AUTH_ERROR_PERMANENT = 202;
  60
  61         /**
  62          * @param RedisConnectionPool $pool
  63          * @param string $server
  64          * @param Redis $conn
  65          * @param LoggerInterface $logger
  66          */
  67         public function __construct(
  68                 RedisConnectionPool $pool, $server, Redis $conn, LoggerInterface $logger
  69         ) {
  70                 $this->pool = $pool;
  71                 $this->server = $server;
  72                 $this->conn = $conn;
  73                 $this->logger = $logger;
  74         }
  75
  76         public function setLogger( LoggerInterface $logger ) {
  77                 $this->logger = $logger;
  78         }
  79
  80         /**
  81          * @return string
  82          * @since 1.23
  83          */
  84         public function getServer() {
  85                 return $this->server;
  86         }
  87
  88         public function getLastError() {
  89                 return $this->lastError;
  90         }
  91
  92         public function clearLastError() {
  93                 $this->lastError = null;
  94         }
  95
  96         /**
  97          * Magic __call handler for most Redis functions.
  98          *
  99          * @param string $name
 100          * @param array $arguments
 101          * @return mixed $res
 102          * @throws RedisException
 103          */
 104         public function __call( $name, $arguments ) {
 105                 // Work around https://github.com/nicolasff/phpredis/issues/70
 106                 $lname = strtolower( $name );
 107                 if (
 108                         ( $lname === 'blpop' || $lname === 'brpop' || $lname === 'brpoplpush' )
 109                         && count( $arguments ) > 1
 110                 ) {
 111                         // Get timeout off the end since it is always required and argument length can vary
 112                         $timeout = end( $arguments );
 113                         // Only give the additional one second buffer if not requesting an infinite timeout
 114                         $this->pool->resetTimeout( $this->conn, ( $timeout > 0 ? $timeout + 1 : $timeout ) );
 115                 }
 116
 117                 return $this->tryCall( $name, $arguments );
 118         }
 119
 120         /**
 121          * Do the method call in the common try catch handler.
 122          *
 123          * @param string $method
 124          * @param array $arguments
 125          * @return mixed $res
 126          * @throws RedisException
 127          */
 128         private function tryCall( $method, $arguments ) {
 129                 $this->conn->clearLastError();
 130                 try {
 131                         $res = $this->conn->$method( ...$arguments );
 132                         $authError = $this->checkAuthentication();
 133                         if ( $authError === self::AUTH_ERROR_TEMPORARY ) {
 134                                 $res = $this->conn->$method( ...$arguments );
 135                         }
 136                         if ( $authError === self::AUTH_ERROR_PERMANENT ) {
 137                                 throw new RedisException( "Failure reauthenticating to Redis." );
 138                         }
 139                 } finally {
 140                         $this->postCallCleanup();
 141                 }
 142
 143                 return $res;
 144         }
 145
 146         /**
 147          * Key Scan
 148          * Handle this explicity due to needing the iterator passed by reference.
 149          * See: https://github.com/phpredis/phpredis#scan
 150          *
 151          * @param int &$iterator
 152          * @param string|null $pattern
 153          * @param int|null $count
 154          * @return array $res
 155          */
 156         public function scan( &$iterator, $pattern = null, $count = null ) {
 157                 return $this->tryCall( 'scan', [ &$iterator, $pattern, $count ] );
 158         }
 159
 160         /**
 161          * Set Scan
 162          * Handle this explicity due to needing the iterator passed by reference.
 163          * See: https://github.com/phpredis/phpredis#sScan
 164          *
 165          * @param string $key
 166          * @param int &$iterator
 167          * @param string|null $pattern
 168          * @param int|null $count
 169          * @return array $res
 170          */
 171         public function sScan( $key, &$iterator, $pattern = null, $count = null ) {
 172                 return $this->tryCall( 'sScan', [ $key, &$iterator, $pattern, $count ] );
 173         }
 174
 175         /**
 176          * Hash Scan
 177          * Handle this explicity due to needing the iterator passed by reference.
 178          * See: https://github.com/phpredis/phpredis#hScan
 179          *
 180          * @param string $key
 181          * @param int &$iterator
 182          * @param string|null $pattern
 183          * @param int|null $count
 184          * @return array $res
 185          */
 186         public function hScan( $key, &$iterator, $pattern = null, $count = null ) {
 187                 return $this->tryCall( 'hScan', [ $key, &$iterator, $pattern, $count ] );
 188         }
 189
 190         /**
 191          * Sorted Set Scan
 192          * Handle this explicity due to needing the iterator passed by reference.
 193          * See: https://github.com/phpredis/phpredis#hScan
 194          *
 195          * @param string $key
 196          * @param int &$iterator
 197          * @param string|null $pattern
 198          * @param int|null $count
 199          * @return array $res
 200          */
 201         public function zScan( $key, &$iterator, $pattern = null, $count = null ) {
 202                 return $this->tryCall( 'zScan', [ $key, &$iterator, $pattern, $count ] );
 203         }
 204
 205         /**
 206          * Handle authentication errors and automatically reauthenticate.
 207          *
 208          * @return int self::AUTH_NO_ERROR, self::AUTH_ERROR_TEMPORARY, or self::AUTH_ERROR_PERMANENT
 209          */
 210         private function checkAuthentication() {
 211                 if ( preg_match( '/^ERR operation not permitted\b/', $this->conn->getLastError() ) ) {
 212                         if ( !$this->pool->reauthenticateConnection( $this->server, $this->conn ) ) {
 213                                 return self::AUTH_ERROR_PERMANENT;
 214                         }
 215                         $this->conn->clearLastError();
 216                         $this->logger->info(
 217                                 "Used automatic re-authentication for Redis.",
 218                                 [ 'redis_server' => $this->server ]
 219                         );
 220                         return self::AUTH_ERROR_TEMPORARY;
 221                 }
 222                 return self::AUTH_NO_ERROR;
 223         }
 224
 225         /**
 226          * Post Redis call cleanup.
 227          *
 228          * @return void
 229          */
 230         private function postCallCleanup() {
 231                 $this->lastError = $this->conn->getLastError() ?: $this->lastError;
 232
 233                 // Restore original timeout in the case of blocking calls.
 234                 $this->pool->resetTimeout( $this->conn );
 235         }
 236
 237         /**
 238          * @param string $script
 239          * @param array $params
 240          * @param int $numKeys
 241          * @return mixed
 242          * @throws RedisException
 243          */
 244         public function luaEval( $script, array $params, $numKeys ) {
 245                 $sha1 = sha1( $script ); // 40 char hex
 246                 $conn = $this->conn; // convenience
 247                 $server = $this->server; // convenience
 248
 249                 // Try to run the server-side cached copy of the script
 250                 $conn->clearLastError();
 251                 $res = $conn->evalSha( $sha1, $params, $numKeys );
 252                 // If we got a permission error reply that means that (a) we are not in
 253                 // multi()/pipeline() and (b) some connection problem likely occurred. If
 254                 // the password the client gave was just wrong, an exception should have
 255                 // been thrown back in getConnection() previously.
 256                 if ( preg_match( '/^ERR operation not permitted\b/', $conn->getLastError() ) ) {
 257                         $this->pool->reauthenticateConnection( $server, $conn );
 258                         $conn->clearLastError();
 259                         $res = $conn->eval( $script, $params, $numKeys );
 260                         $this->logger->info(
 261                                 "Used automatic re-authentication for Lua script '$sha1'.",
 262                                 [ 'redis_server' => $server ]
 263                         );
 264                 }
 265                 // If the script is not in cache, use eval() to retry and cache it
 266                 if ( preg_match( '/^NOSCRIPT/', $conn->getLastError() ) ) {
 267                         $conn->clearLastError();
 268                         $res = $conn->eval( $script, $params, $numKeys );
 269                         $this->logger->info(
 270                                 "Used eval() for Lua script '$sha1'.",
 271                                 [ 'redis_server' => $server ]
 272                         );
 273                 }
 274
 275                 if ( $conn->getLastError() ) { // script bug?
 276                         $this->logger->error(
 277                                 'Lua script error on server "{redis_server}": {lua_error}',
 278                                 [
 279                                         'redis_server' => $server,
 280                                         'lua_error' => $conn->getLastError()
 281                                 ]
 282                         );
 283                 }
 284
 285                 $this->lastError = $conn->getLastError() ?: $this->lastError;
 286
 287                 return $res;
 288         }
 289
 290         /**
 291          * @param Redis $conn
 292          * @return bool
 293          */
 294         public function isConnIdentical( Redis $conn ) {
 295                 return $this->conn === $conn;
 296         }
 297
 298         function __destruct() {
 299                 $this->pool->freeConnection( $this->server, $this->conn );
 300         }
 301 }