includes/libs/objectcache/MemcachedBagOStuff.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 namespace Wikimedia\ObjectCache;
  21
  22 use Exception;
  23 use InvalidArgumentException;
  24 use RuntimeException;
  25
  26 /**
  27  * Store data in a memcached server or memcached cluster.
  28  *
  29  * This is a base class for MemcachedPhpBagOStuff and MemcachedPeclBagOStuff.
  30  *
  31  * @ingroup Cache
  32  */
  33 abstract class MemcachedBagOStuff extends MediumSpecificBagOStuff {
  34         /** @var string Routing prefix appended to keys during operations */
  35         protected $routingPrefix;
  36
  37         /**
  38          * @param array $params Additional parameters include:
  39          *   - routingPrefix: a routing prefix of the form "<datacenter>/<cluster>/" used to convey
  40          *      the location/strategy to use for handling keys accessed from this instance. The prefix
  41          *      is prepended to keys during cache operations. The memcached proxy must preserve these
  42          *      prefixes in any responses that include requested keys (e.g. get/gets). The proxy is
  43          *      also assumed to strip the routing prefix from the stored key name, which allows for
  44          *      unprefixed access. This can be used with mcrouter. [optional]
  45          */
  46         public function __construct( array $params ) {
  47                 $params['segmentationSize'] ??= 917_504; // < 1MiB
  48                 parent::__construct( $params );
  49
  50                 $this->routingPrefix = $params['routingPrefix'] ?? '';
  51
  52                 // ...and does not use special disk-cache plugins
  53                 $this->attrMap[self::ATTR_DURABILITY] = self::QOS_DURABILITY_SERVICE;
  54         }
  55
  56         /**
  57          * Format a cache key.
  58          *
  59          * @since 1.27
  60          * @see BagOStuff::makeKeyInternal
  61          *
  62          * @param string $keyspace
  63          * @param string[]|int[] $components
  64          *
  65          * @return string
  66          */
  67         protected function makeKeyInternal( $keyspace, $components ) {
  68                 // Memcached keys have a maximum length of 255 characters. From that,
  69                 // subtract the number of characters we need for the keyspace and for
  70                 // the separator character needed for each argument. To handle some
  71                 // custom prefixes used by thing like WANObjectCache, limit to 205.
  72                 $charsLeft = 205 - strlen( $keyspace ) - count( $components );
  73
  74                 foreach ( $components as &$component ) {
  75                         $component = strtr( $component, ' ', '_' );
  76
  77                         // Make sure %, #, and non-ASCII chars are escaped
  78                         $component = preg_replace_callback(
  79                                 '/[^\x21-\x22\x24\x26-\x39\x3b-\x7e]+/',
  80                                 static function ( $m ) {
  81                                         return rawurlencode( $m[0] );
  82                                 },
  83                                 $component
  84                         );
  85
  86                         // 33 = 32 characters for the MD5 + 1 for the '#' prefix.
  87                         if ( $charsLeft > 33 && strlen( $component ) > $charsLeft ) {
  88                                 $component = '#' . md5( $component );
  89                         }
  90
  91                         $charsLeft -= strlen( $component );
  92                 }
  93
  94                 if ( $charsLeft < 0 ) {
  95                         return $keyspace . ':BagOStuff-long-key:##' . md5( implode( ':', $components ) );
  96                 }
  97
  98                 return $keyspace . ':' . implode( ':', $components );
  99         }
 100
 101         protected function requireConvertGenericKey(): bool {
 102                 return true;
 103         }
 104
 105         /**
 106          * Ensure that a key is safe to use (contains no control characters and no
 107          * characters above the ASCII range.)
 108          *
 109          * @param string $key
 110          *
 111          * @return string
 112          * @throws Exception
 113          */
 114         public function validateKeyEncoding( $key ) {
 115                 if ( preg_match( '/[^\x21-\x7e]+/', $key ) ) {
 116                         throw new InvalidArgumentException( "Key contains invalid characters: $key" );
 117                 }
 118
 119                 return $key;
 120         }
 121
 122         /**
 123          * @param string $key
 124          *
 125          * @return string
 126          */
 127         protected function validateKeyAndPrependRoute( $key ) {
 128                 $this->validateKeyEncoding( $key );
 129
 130                 if ( $this->routingPrefix === '' ) {
 131                         return $key;
 132                 }
 133
 134                 if ( $key[0] === '/' ) {
 135                         throw new RuntimeException( "Key '$key' already contains a route." );
 136                 }
 137
 138                 return $this->routingPrefix . $key;
 139         }
 140
 141         /**
 142          * @param string $key
 143          *
 144          * @return string
 145          */
 146         protected function stripRouteFromKey( $key ) {
 147                 if ( $this->routingPrefix === '' ) {
 148                         return $key;
 149                 }
 150
 151                 if ( str_starts_with( $key, $this->routingPrefix ) ) {
 152                         return substr( $key, strlen( $this->routingPrefix ) );
 153                 }
 154
 155                 return $key;
 156         }
 157
 158         /**
 159          * @param int|float $exptime
 160          *
 161          * @return int
 162          */
 163         protected function fixExpiry( $exptime ) {
 164                 if ( $exptime < 0 ) {
 165                         // The PECL driver does not seem to like negative relative values
 166                         $expiresAt = $this->getCurrentTime() + $exptime;
 167                 } elseif ( $this->isRelativeExpiration( $exptime ) ) {
 168                         // TTLs higher than 30 days will be detected as absolute TTLs
 169                         // (UNIX timestamps), and will result in the cache entry being
 170                         // discarded immediately because the expiry is in the past.
 171                         // Clamp expires >30d at 30d, unless they're >=1e9 in which
 172                         // case they are likely to really be absolute (1e9 = 2011-09-09)
 173                         $expiresAt = min( $exptime, self::TTL_MONTH );
 174                 } else {
 175                         $expiresAt = $exptime;
 176                 }
 177
 178                 return (int)$expiresAt;
 179         }
 180
 181         protected function doIncrWithInit( $key, $exptime, $step, $init, $flags ) {
 182                 if ( $flags & self::WRITE_BACKGROUND ) {
 183                         return $this->doIncrWithInitAsync( $key, $exptime, $step, $init );
 184                 } else {
 185                         return $this->doIncrWithInitSync( $key, $exptime, $step, $init );
 186                 }
 187         }
 188
 189         /**
 190          * @param string $key
 191          * @param int $exptime
 192          * @param int $step
 193          * @param int $init
 194          *
 195          * @return bool True on success, false on failure
 196          */
 197         abstract protected function doIncrWithInitAsync( $key, $exptime, $step, $init );
 198
 199         /**
 200          * @param string $key
 201          * @param int $exptime
 202          * @param int $step
 203          * @param int $init
 204          *
 205          * @return int|bool New value or false on failure
 206          */
 207         abstract protected function doIncrWithInitSync( $key, $exptime, $step, $init );
 208 }
 209
 210 /** @deprecated class alias since 1.43 */
 211 class_alias( MemcachedBagOStuff::class, 'MemcachedBagOStuff' );